Java AssertJUnit.assertSame示例

示例#1

文件： CookieJarTest.java 项目： jimm/babble

  @Test
  public void testSecure() throws MalformedURLException {
    CookieJar jar = new CookieJar();
    Cookie cookie = new Cookie("myname", "myvalue");
    cookie.setDomain(".10gen.com");
    cookie.setPath("/");
    cookie.setSecure(true);

    jar.addCookie(new URL("https://www.10gen.com"), cookie);

    assertSame(cookie, jar.getActiveCookies(new URL("https://10gen.com/")).get("myname"));
    assertSame(0, jar.getActiveCookies(new URL("http://10gen.com/")).size());
  }

示例#2

文件： CookieJarTest.java 项目： jimm/babble

  @Test
  public void testPath() throws MalformedURLException {
    CookieJar jar = new CookieJar();
    Cookie cookie = new Cookie("myname", "myvalue");
    cookie.setDomain(".10gen.com");
    cookie.setPath("/subdir");

    jar.addCookie(new URL("http://www.10gen.com/subdir"), cookie);

    assertSame(
        cookie,
        jar.getActiveCookies(new URL("http://10gen.com/subdir/moo/baa.html")).get("myname"));
    assertSame(0, jar.getActiveCookies(new URL("http://10gen.com/otherdir/")).size());
  }

示例#3

文件： CookieJarTest.java 项目： jimm/babble

  @Test
  public void testSimple() throws MalformedURLException {
    CookieJar jar = new CookieJar();
    Cookie cookie = new Cookie("myname", "myvalue");
    cookie.setDomain("10gen.com");
    cookie.setPath("/");

    jar.addCookie(new URL("http://10gen.com/"), cookie);

    // make sure it was actually saved
    assertSame(cookie, jar.getAll().get("myname"));

    // make sure it would resent to the same url
    assertSame(cookie, jar.getActiveCookies(new URL("http://10gen.com/")).get("myname"));

    // make sure it won't be sent elsewhere
    URL otherUrl = new URL("http://someotherhost.com/with/random/path");
    assertEquals(0, jar.getActiveCookies(otherUrl).size());
  }

示例#4

文件： ArtifactLocatorTest.java 项目： springirl/jstd-maven-plugin

 public void shouldFindArtifact() {
   when(artifactFactory.createArtifact(
           coord.getGroupId(), coord.getArtifactId(), coord.getVersion(), "", coord.getFileType()))
       .thenReturn(goodArtifact);
   try {
     assertSame(locator.getAbsolutePathToArtifact(coord), A_PATH);
   } catch (Exception e) {
     fail("Should not have thrown an exception.");
   }
 }

示例#5

文件： CookieJarTest.java 项目： jimm/babble

  @Test
  public void testInvalidDomain() throws MalformedURLException {
    CookieJar jar = new CookieJar();
    Cookie cookie = new Cookie("myname", "myvalue");
    cookie.setDomain(".10gen.com");
    cookie.setPath("/subdir");

    jar.addCookie(new URL("http://othersite.com/"), cookie);

    assertSame(0, jar.getAll().size());
  }

示例#6

  // -------------------------------------------------------------------------
  @Test
  public void testGetConfigByUid() {
    final SimpleExchange target = new SimpleExchange();
    target.setName("Test");

    when(_underlying.getConfig(eq(SimpleExchange.class), eq(UID))).thenReturn(target);

    Response test =
        _resource.get(OID.toString(), SimpleExchange.class.getName(), UID.getVersion(), "", "");
    assertEquals(Status.OK.getStatusCode(), test.getStatus());
    assertSame(target, test.getEntity());
  }

示例#7

文件： InfinispanDefaultCacheFactoryBeanContextTest.java 项目： mbrukman/infinispan

  @Test
  public final void shouldAlwaysReturnTheSameCache() {
    final Cache<Object, Object> testDefaultCache1 =
        this.applicationContext.getBean(DEFAULT_CACHE_NAME, Cache.class);
    final Cache<Object, Object> testDefaultCache2 =
        this.applicationContext.getBean(DEFAULT_CACHE_NAME, Cache.class);

    assertSame(
        "InfinispanDefaultCacheFactoryBean should always return the same cache instance when being "
            + "called repeatedly. However, the cache instances are not the same.",
        testDefaultCache1,
        testDefaultCache2);
  }

示例#8

文件： AbstractRegistryTest.java 项目： rasata/WebHarvest

 @Test
 public void lookupBound() throws Exception {
   registry.bind(KEY, VALUE);
   final String result = registry.lookup(KEY);
   assertSame("Unexpected value found", VALUE, result);
 }

示例#9

文件： CachingFunctionRepositoryCompilerTest.java 项目： henriqueolliveira/OG-Platform

  public void testCompileFunction() {
    final InMemoryFunctionRepository functions = new InMemoryFunctionRepository();
    final MockFunction alwaysValid = new MockFunction("always valid", null, null);
    final MockFunction validUntil = new MockFunction("valid until", null, 30L);
    final MockFunction validFrom = new MockFunction("valid from", 30L, null);
    final MockFunction validWithin = new MockFunction("valid within", 30L, 30L);
    functions.addFunction(alwaysValid);
    functions.addFunction(validUntil);
    functions.addFunction(validFrom);
    functions.addFunction(validWithin);
    final CachingFunctionRepositoryCompiler compiler = new CachingFunctionRepositoryCompiler();
    final CompiledFunctionService context =
        new CompiledFunctionService(functions, compiler, new FunctionCompilationContext());
    final Instant timestamp = Instant.now();

    // Everything compiled once
    final CompiledFunctionRepository compiledFunctionsNow =
        context.compileFunctionRepository(timestamp);
    assertSame(
        alwaysValid,
        compiledFunctionsNow.getDefinition(alwaysValid.getUniqueId()).getFunctionDefinition());
    assertSame(
        validUntil,
        compiledFunctionsNow.getDefinition(validUntil.getUniqueId()).getFunctionDefinition());
    assertSame(
        validFrom,
        compiledFunctionsNow.getDefinition(validFrom.getUniqueId()).getFunctionDefinition());
    assertSame(
        validWithin,
        compiledFunctionsNow.getDefinition(validWithin.getUniqueId()).getFunctionDefinition());
    assertEquals(1, alwaysValid._compileCount.get());
    assertEquals(1, validUntil._compileCount.get());
    assertEquals(1, validFrom._compileCount.get());
    assertEquals(1, validWithin._compileCount.get());

    // All previously compiled ones still valid, so should use the "previous" cache
    final CompiledFunctionRepository compiledFunctionsAheadWithin =
        context.compileFunctionRepository(timestamp.plusMillis(29L));
    assertSame(compiledFunctionsNow, compiledFunctionsAheadWithin);
    assertEquals(1, alwaysValid._compileCount.get());
    assertEquals(1, validUntil._compileCount.get());
    assertEquals(1, validFrom._compileCount.get());
    assertEquals(1, validWithin._compileCount.get());

    // All previously compiled ones still valid, so should use the "previous" cache
    final CompiledFunctionRepository compiledFunctionsAheadLimit =
        context.compileFunctionRepository(timestamp.plusMillis(30L));
    assertSame(compiledFunctionsNow, compiledFunctionsAheadLimit);
    assertEquals(1, alwaysValid._compileCount.get());
    assertEquals(1, validUntil._compileCount.get());
    assertEquals(1, validFrom._compileCount.get());
    assertEquals(1, validWithin._compileCount.get());

    // Some functions to be recompiled, others from the "previous" cache
    final CompiledFunctionRepository compiledFunctionsAheadBeyond =
        context.compileFunctionRepository(timestamp.plusMillis(31L));
    assertNotSame(compiledFunctionsNow, compiledFunctionsAheadBeyond);
    assertSame(
        compiledFunctionsNow.getDefinition(alwaysValid.getUniqueId()),
        compiledFunctionsAheadBeyond.getDefinition(alwaysValid.getUniqueId()));
    assertNotSame(
        compiledFunctionsNow.getDefinition(validUntil.getUniqueId()),
        compiledFunctionsAheadBeyond.getDefinition(validUntil.getUniqueId()));
    assertSame(
        compiledFunctionsNow.getDefinition(validFrom.getUniqueId()),
        compiledFunctionsAheadBeyond.getDefinition(validFrom.getUniqueId()));
    assertNotSame(
        compiledFunctionsNow.getDefinition(validWithin.getUniqueId()),
        compiledFunctionsAheadBeyond.getDefinition(validWithin.getUniqueId()));
    assertEquals(1, alwaysValid._compileCount.get());
    assertEquals(2, validUntil._compileCount.get());
    assertEquals(1, validFrom._compileCount.get());
    assertEquals(2, validWithin._compileCount.get());

    // All previously compiled functions, so should use the "ahead" cache
    final CompiledFunctionRepository compiledFunctionsBeforeWithin =
        context.compileFunctionRepository(timestamp.minusMillis(30L));
    assertSame(compiledFunctionsNow, compiledFunctionsBeforeWithin);
    assertEquals(1, alwaysValid._compileCount.get());
    assertEquals(2, validUntil._compileCount.get());
    assertEquals(1, validFrom._compileCount.get());
    assertEquals(2, validWithin._compileCount.get());

    // Some functions to be recompiled, others from the "ahead" cache
    final CompiledFunctionRepository compiledFunctionsBeforeBeyond =
        context.compileFunctionRepository(timestamp.minusMillis(31L));
    assertNotSame(compiledFunctionsNow, compiledFunctionsBeforeBeyond);
    assertSame(
        compiledFunctionsNow.getDefinition(alwaysValid.getUniqueId()),
        compiledFunctionsBeforeBeyond.getDefinition(alwaysValid.getUniqueId()));
    assertSame(
        compiledFunctionsNow.getDefinition(validUntil.getUniqueId()),
        compiledFunctionsBeforeBeyond.getDefinition(validUntil.getUniqueId()));
    assertNotSame(
        compiledFunctionsNow.getDefinition(validFrom.getUniqueId()),
        compiledFunctionsBeforeBeyond.getDefinition(validFrom.getUniqueId()));
    assertNotSame(
        compiledFunctionsNow.getDefinition(validWithin.getUniqueId()),
        compiledFunctionsBeforeBeyond.getDefinition(validWithin.getUniqueId()));
    assertEquals(1, alwaysValid._compileCount.get());
    assertEquals(2, validUntil._compileCount.get());
    assertEquals(2, validFrom._compileCount.get());
    assertEquals(3, validWithin._compileCount.get());
  }

示例#10

文件： ExternalIdSearchTest.java 项目： nagyist/OpenGamma-Commons

 public void test_withSearchType_same() {
   ExternalIdSearch base = ExternalIdSearch.of(ExternalIdSearchType.ALL, ExternalId.of("A", "B"));
   assertSame(base, base.withSearchType(ExternalIdSearchType.ALL));
 }

示例#11

文件： VersionCorrectionTest.java 项目： sachinpolekar/OG-Platform

 public void test_ofCorrectedTo_Instant_null() {
   VersionCorrection test = VersionCorrection.ofCorrectedTo((InstantProvider) null);
   assertSame(VersionCorrection.LATEST, test);
 }

示例#12

文件： VersionCorrectionTest.java 项目： sachinpolekar/OG-Platform

 public void test_of_InstantInstant_nulls() {
   VersionCorrection test = VersionCorrection.of((InstantProvider) null, (InstantProvider) null);
   assertSame(VersionCorrection.LATEST, test);
 }

示例#13

文件： VersionCorrectionTest.java 项目： sachinpolekar/OG-Platform

 public void test_of_VersionCorrection_null() {
   VersionCorrection test = VersionCorrection.of((VersionCorrection) null);
   assertSame(VersionCorrection.LATEST, test);
 }

示例#14

文件： VersionCorrectionTest.java 项目： sachinpolekar/OG-Platform

 // -------------------------------------------------------------------------
 public void test_of_VersionCorrection() {
   VersionCorrection base = VersionCorrection.of(INSTANT1, INSTANT2);
   VersionCorrection test = VersionCorrection.of(base);
   assertSame(base, test);
 }

示例#15

文件： VersionCorrectionTest.java 项目： sachinpolekar/OG-Platform

 // -------------------------------------------------------------------------
 public void test_withLatestFixed_noNulls() {
   VersionCorrection test = VersionCorrection.of(INSTANT1, INSTANT2);
   assertSame(test, test.withLatestFixed(INSTANT3));
 }

示例#16

文件： VersionCorrectionTest.java 项目： sachinpolekar/OG-Platform

 public void test_parse_latests() {
   VersionCorrection test = VersionCorrection.parse("VLATEST.CLATEST");
   assertSame(VersionCorrection.LATEST, test);
 }