Example #1
1
  @Ignore
  @Test
  public void testLegendBaseline() throws Exception {
    assertTrue("Folder", map.getLegend().get(0) instanceof Folder);

    Folder folder = (Folder) map.getLegend().get(0);

    assertSame(
        "Reference Resource 0",
        map.getLayersInternal().get(0),
        ((LayerLegendItem) folder.getItems().get(0)).getLayer());
    assertSame(
        "Reference Resource 1",
        map.getLayersInternal().get(1),
        ((LayerLegendItem) folder.getItems().get(1)).getLayer());

    assertSame(
        "Reference Resource 2",
        map.getLayersInternal().get(2),
        ((LayerLegendItem) map.getLegend().get(1)).getLayer());
    assertSame(
        "Reference Resource 3",
        map.getLayersInternal().get(3),
        ((LayerLegendItem) map.getLegend().get(2)).getLayer());
  }
Example #2
0
  @Test
  public void testNoAdd2WithCircDep() {
    Foo.instanceCounter = 0;
    PetiteContainer pc = new PetiteContainer();
    pc.registerBean(Foo.class);
    pc.registerBean(Zoo.class);
    pc.registerBean(Boo.class);

    Boo boo = (Boo) pc.getBean("boo");
    Foo foo = (Foo) pc.getBean("foo");
    Zoo zoo = (Zoo) pc.getBean("zoo");

    assertNotNull(boo.getFoo());
    assertSame(foo, boo.getFoo());

    assertNotNull(zoo.boo);
    assertSame(boo, zoo.boo);
    assertSame(zoo, boo.zoo);

    Boo boo2 = (Boo) pc.getBean("boo");
    assertNotNull(boo2);
    assertSame(boo, boo2);
    assertFalse(boo.orders.isEmpty());
    assertNotNull(boo2.getFoo());
    assertSame(foo, boo2.getFoo());
    assertEquals(1, boo2.getFoo().hello());
    assertEquals(1, boo2.getFoo().getCounter());
    assertEquals("[first, second, third, init, beforeLast, last]", boo.orders.toString());
  }
  @Test
  public void targetIsNotNull() {
    assertNotNull(target);

    assertNotNull(target.theNameForTheMeter);
    Meter meter =
        (Meter)
            forInjectMetricField(
                metricRegistry, InjectMetricTest.Target.class, "theNameForTheMeter");
    assertSame(target.theNameForTheMeter, meter);

    assertNotNull(target.timer);
    Timer timer =
        (Timer) forInjectMetricField(metricRegistry, InjectMetricTest.Target.class, "timer");
    assertSame(target.timer, timer);

    assertNotNull(target.counter);
    Counter ctr =
        (Counter) forInjectMetricField(metricRegistry, InjectMetricTest.Target.class, "counter");
    assertSame(target.counter, ctr);

    assertNotNull(target.histogram);
    Histogram hist =
        (Histogram)
            forInjectMetricField(metricRegistry, InjectMetricTest.Target.class, "histogram");
    assertSame(target.histogram, hist);
  }
 @Test
 public void testGetConnection() throws SQLException {
   assertSame(mockConnections[0], dataSource.getConnection());
   assertSame(mockConnections[1], dataSource.getConnection());
   assertSame(mockConnections[2], dataSource.getConnection());
   assertSame(mockConnections[3], dataSource.getConnection());
 }
  @Test
  public void get_with_hashingStrategy() {
    UnifiedSetWithHashingStrategy<Person> people =
        UnifiedSetWithHashingStrategy.newSet(
                HashingStrategies.nullSafeHashingStrategy(LAST_NAME_HASHING_STRATEGY), 2)
            .withAll(PEOPLE.castToList());

    // Putting null then testing geting a null
    Verify.assertSize(3, people.with((Person) null));
    Assert.assertNull(people.get(null));

    // Testing it is getting the same reference
    Assert.assertSame(JOHNSMITH, people.get(JANESMITH));
    Assert.assertSame(JOHNSMITH, people.get(JOHNSMITH));
    Assert.assertSame(JOHNDOE, people.get(JANEDOE));
    Assert.assertSame(JOHNDOE, people.get(JOHNDOE));

    Assert.assertSame(JOHNSMITH, people.get(new Person("Anything", "Smith")));
    Assert.assertNull(people.get(new Person("John", "NotHere")));

    // Testing get throws NullPointerException if the hashingStrategy is not null safe
    Verify.assertThrows(
        NullPointerException.class,
        () -> {
          UnifiedSetWithHashingStrategy.newSet(LAST_NAME_HASHING_STRATEGY).get(null);
        });
  }
  @Test
  public void setsUpApplicationContextBeforeCallToRequestHandler() throws Exception {
    ContainerRequest containerRequest = mockContainerRequest();
    ContainerResponse containerResponse = mockContainerResponse();
    EnvironmentContext environmentContext = mock(EnvironmentContext.class);

    ApplicationContext[] applicationContextThatRequestHandlerCalledWith = new ApplicationContext[1];
    doAnswer(
            invocation -> {
              applicationContextThatRequestHandlerCalledWith[0] = ApplicationContext.getCurrent();
              return null;
            })
        .when(requestHandler)
        .handleRequest(containerRequest, containerResponse);

    everrestProcessor.process(containerRequest, containerResponse, environmentContext);
    assertNotNull(applicationContextThatRequestHandlerCalledWith[0]);
    assertSame(
        containerRequest, applicationContextThatRequestHandlerCalledWith[0].getContainerRequest());
    assertSame(
        containerResponse,
        applicationContextThatRequestHandlerCalledWith[0].getContainerResponse());
    assertSame(
        dependencySupplier,
        applicationContextThatRequestHandlerCalledWith[0].getDependencySupplier());
  }
  @Test
  public void testPrepareResponse() throws UnknownHostException {
    HttpClientSPIAgent httpClientSPIAgent =
        new HttpClientSPIAgent(
            _spiConfiguration, new MockRegistrationReference(new MockIntraband()));

    MockHttpServletRequest mockHttpServletRequest = new MockHttpServletRequest();

    mockHttpServletRequest.setAttribute(WebKeys.SPI_AGENT_PORTLET, _portlet);

    MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();

    HttpServletResponse httpServletResponse =
        httpClientSPIAgent.prepareResponse(mockHttpServletRequest, mockHttpServletResponse);

    Assert.assertSame(
        mockHttpServletResponse,
        mockHttpServletRequest.getAttribute(WebKeys.SPI_AGENT_ORIGINAL_RESPONSE));
    Assert.assertNotNull(mockHttpServletRequest.getAttribute(WebKeys.SPI_AGENT_RESPONSE));

    Assert.assertSame(BufferCacheServletResponse.class, httpServletResponse.getClass());

    BufferCacheServletResponse bufferCacheServletResponse =
        (BufferCacheServletResponse) httpServletResponse;

    ServletResponse servletResponse = bufferCacheServletResponse.getResponse();

    Assert.assertSame(ReadOnlyServletResponse.class, servletResponse.getClass());

    ReadOnlyServletResponse readOnlyServletResponse = (ReadOnlyServletResponse) servletResponse;

    Assert.assertSame(mockHttpServletResponse, readOnlyServletResponse.getResponse());
  }
  @Test
  public void getPullService() {
    assertSame(null, content.getPullService());

    content.setPullService(pullService);
    assertSame(pullService, content.getPullService());
  }
  /**
   * Test the old reader is still open until all searchers using it are closed
   *
   * @throws Exception
   */
  @Test
  public void testOldReaderStillOpenTillAllSearchersClosed() throws Exception {
    final DefaultIndexEngine engine = getRamDirectory();

    final IndexSearcher oldSearcher1 = engine.getSearcher();
    final IndexSearcher oldSearcher2 = engine.getSearcher();
    final IndexSearcher oldSearcher3 = engine.getSearcher();
    final IndexReader reader = oldSearcher1.getIndexReader();
    assertSame("should be same until something is written", oldSearcher1, oldSearcher2);
    assertSame("should be same until something is written", oldSearcher1, oldSearcher3);

    writeTestDocument(engine);

    oldSearcher1.close();

    final IndexSearcher newSearcher = engine.getSearcher();
    assertNotSame(oldSearcher1, newSearcher);
    final IndexReader newReader = newSearcher.getIndexReader();
    assertNotSame(reader, newReader);
    assertReaderOpen(reader);
    assertReaderOpen(newReader);
    oldSearcher2.close();
    assertReaderOpen(reader);
    oldSearcher3.close();
    assertReaderClosed(reader);
    assertReaderOpen(newReader);
  }
 @Test
 public void testSameInstance() {
   // If no normalization is required we should get the same instance.
   String id = new String("Example.html");
   assertSame(id, nfn.getFileName(id));
   assertSame(id, nfn.getFileName(new String("Example.html")));
 }
  @Test
  public void testAcceptsComponentParametersForComponent() {
    Reader script =
        new StringReader(
            "A = org.picocontainer.script.testmodel.A\n"
                + "B = org.picocontainer.script.testmodel.B\n"
                + "container {\n"
                + "    component(:key => 'a1', :class => A)\n"
                + "    component(:key => 'a2', :class => A)\n"
                + "    component(:key => 'b1', :class => B, :parameters => [ key('a1') ])\n"
                + "    component(:key => 'b2', :class => B, :parameters => key('a2'))\n"
                + "}");

    PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
    A a1 = (A) pico.getComponent("a1");
    A a2 = (A) pico.getComponent("a2");
    B b1 = (B) pico.getComponent("b1");
    B b2 = (B) pico.getComponent("b2");

    assertNotNull(a1);
    assertNotNull(a2);
    assertNotNull(b1);
    assertNotNull(b2);

    assertSame(a1, b1.getA());
    assertSame(a2, b2.getA());
    assertNotSame(a1, a2);
    assertNotSame(b1, b2);
  }
  private void test(Object original, boolean same) throws IOException, ClassNotFoundException {
    try {
      Object marshalled = this.marshaller.marshal(original);

      if (original != null) {
        assertTrue(original instanceof Serializable);
      }
      if (marshalled != null) {
        assertTrue(marshalled instanceof Serializable);
      }

      if (same) {
        assertSame(original, marshalled);
      } else {
        assertNotSame(original, marshalled);
      }

      Object unmarshalled = this.marshaller.unmarshal(marshalled);

      if (same) {
        assertSame(marshalled, unmarshalled);
      } else {
        assertNotSame(marshalled, unmarshalled);
        assertEquals(original, unmarshalled);
      }
    } catch (IllegalArgumentException e) {
      assertFalse(same);
      assertFalse(original instanceof Serializable);
    }
  }
Example #13
0
 @Test
 public void testWithNullAsKey() throws Exception {
   final T cache = getInstance(1000, 1000);
   final Object o = new Object();
   assertEquals(0, (long) cache.size());
   assertFalse(cache.contains(null));
   assertNull(cache.get(null));
   // Add entry with null as key ...
   cache.put(null, o);
   assertEquals(1, (long) cache.size());
   assertTrue(cache.contains(null));
   assertSame(o, cache.get(null));
   // Add another entry ...
   cache.put(o, o);
   assertEquals(2, (long) cache.size());
   // Remove entry with null as key ...
   assertSame(o, cache.remove(null).getValue());
   assertEquals(1, (long) cache.size());
   assertFalse(cache.contains(null));
   assertNull(cache.get(null));
   // Try to remove entry with null as key again ...
   assertNull(cache.remove(null));
   assertEquals(1, (long) cache.size());
   assertFalse(cache.contains(null));
   assertNull(cache.get(null));
 }
Example #14
0
  /** The URL instance must be able to set and get an access token instance */
  @Test
  public void testCanSetAndGetAnAccessTokenInstance() {
    final AccessToken accessToken = new AccessToken();

    assertSame(url, url.setAccessToken(accessToken));
    assertSame(accessToken, url.getAccessToken());
  }
Example #15
0
 /** Moo */
 @Test
 public void testGet() {
   words.add("moo");
   words.add("cow");
   assertSame("moo", words.get(0));
   assertSame("cow", words.get(1));
 }
  @Test
  public void testGetCache() throws Exception {

    // Create on missing

    IntrabandPortalCacheManager<String, String> intraBandPortalCacheManager =
        new IntrabandPortalCacheManager<String, String>(_mockRegistrationReference);

    Map<String, PortalCache<?, ?>> portalCaches = getPortalCaches(intraBandPortalCacheManager);

    Assert.assertTrue(portalCaches.isEmpty());

    String portalCacheName = "portalCacheName";

    PortalCache<?, ?> portalCache = intraBandPortalCacheManager.getCache(portalCacheName);

    Assert.assertNotNull(portalCache);
    Assert.assertEquals(portalCacheName, portalCache.getName());
    Assert.assertEquals(1, portalCaches.size());
    Assert.assertSame(portalCache, portalCaches.get(portalCacheName));

    // Get existing

    PortalCache<?, ?> portalCache2 = intraBandPortalCacheManager.getCache(portalCacheName);

    Assert.assertNotNull(portalCache2);
    Assert.assertEquals(portalCacheName, portalCache2.getName());
    Assert.assertEquals(1, portalCaches.size());
    Assert.assertSame(portalCache, portalCache2);
  }
Example #17
0
  @Test
  public void toArray() {
    assertTrue(Arrays.equals(toTest.toArray(), new Serializable[] {}));

    toTest.add("Test1");
    toTest.add("Test2");

    assertTrue(Arrays.equals(toTest.toArray(), new String[] {"Test1", "Test2"}));

    String[] sArray = new String[2];
    String[] result = toTest.toArray(sArray);

    assertSame(sArray, result);
    assertTrue(Arrays.equals(sArray, new String[] {"Test1", "Test2"}));

    sArray = new String[3];
    result = toTest.toArray(sArray);

    assertSame(sArray, result);
    assertTrue(Arrays.equals(sArray, new String[] {"Test1", "Test2", null}));

    result = toTest.toArray(new String[] {});

    assertTrue(Arrays.equals(result, new String[] {"Test1", "Test2"}));
  }
Example #18
0
 private void failTest(Handler<TestContext> thrower) {
   AtomicReference<Throwable> failure = new AtomicReference<>();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 try {
                   thrower.handle(context);
                 } catch (Error | RuntimeException e) {
                   failure.set(e);
                   throw e;
                 }
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertFalse(result.succeeded());
   assertTrue(result.failed());
   assertNotNull(result.failure());
   assertSame(failure.get().getMessage(), result.failure().message());
   assertSame(failure.get(), result.failure().cause());
 }
  @Test
  public void testLoadAndSaveAggregate() {
    UUID identifier = UUID.randomUUID();
    DomainEventMessage event1 =
        new GenericDomainEventMessage<String>(
            identifier, (long) 1, "Mock contents", MetaData.emptyInstance());
    DomainEventMessage event2 =
        new GenericDomainEventMessage<String>(
            identifier, (long) 2, "Mock contents", MetaData.emptyInstance());
    when(mockEventStore.readEvents("test", identifier))
        .thenReturn(new SimpleDomainEventStream(event1, event2));

    TestAggregate aggregate = testSubject.load(identifier, null);

    assertEquals(0, aggregate.getUncommittedEventCount());
    assertEquals(2, aggregate.getHandledEvents().size());
    assertSame(event1, aggregate.getHandledEvents().get(0));
    assertSame(event2, aggregate.getHandledEvents().get(1));

    // now the aggregate is loaded (and hopefully correctly locked)
    StubDomainEvent event3 = new StubDomainEvent();

    aggregate.apply(event3);

    CurrentUnitOfWork.commit();

    verify(mockEventBus).publish(isA(DomainEventMessage.class));
    verify(mockEventBus, never()).publish(event1);
    verify(mockEventBus, never()).publish(event2);
    verify(mockEventStore, times(1)).appendEvents(eq("test"), isA(DomainEventStream.class));
    assertEquals(0, aggregate.getUncommittedEventCount());
  }
  @Test
  public void testGetPredicate() {
    String[] data = {"a", "b", "c"};
    DynamicUserDefinedPredicateFactory dp = createDynamicPredicate();
    for (String d : data) {
      addLast(dp, d);
    }

    // test evaluate with atom as argument
    for (String d : data) {
      Term inputArg = atom(d);
      Term[] args = new Term[] {inputArg};
      Predicate e = dp.getPredicate(args);
      assertTrue(e.isRetryable());
      assertTrue(e.evaluate(args));
      assertSame(inputArg, args[0]);
      assertFalse(e.evaluate(args));
      assertSame(inputArg, args[0]);
    }

    // test evaluate with variable as argument
    Term inputArg = variable();
    Term[] args = new Term[] {inputArg};
    Predicate e = dp.getPredicate(args);
    assertTrue(e.isRetryable());
    for (String d : data) {
      assertTrue(e.evaluate(args));
      assertSame(TermType.ATOM, args[0].getType());
      assertEquals(d, args[0].getName());
    }
    assertFalse(e.evaluate(args));
    assertSame(inputArg, args[0]);
    assertSame(inputArg, args[0].getTerm());
  }
 private void assertCalloutExceptionIsFilled(
     final CalloutException exception, final ICalloutField field) {
   Assert.assertSame(
       "Invalid executor for " + exception, calloutExecutor, exception.getCalloutExecutor());
   Assert.assertSame("Invalid field for " + exception, field, exception.getCalloutField());
   // exception.getCalloutInstance();
 }
  @Test
  public void testSetArguments()
      throws NoSuchFieldException, SecurityException, IllegalArgumentException,
          IllegalAccessException {
    TestBean bean = new TestBean();
    TestMethodProperty<String> property = new TestMethodProperty<String>(bean, "name");
    Object[] getArgs = property.getGetArgs();
    Object[] setArgs = property.getSetArgs();

    Field getArgsField = TestMethodProperty.class.getDeclaredField("getArgs");
    getArgsField.setAccessible(true);

    Field setArgsField = TestMethodProperty.class.getDeclaredField("setArgs");
    setArgsField.setAccessible(true);

    Assert.assertSame(
        "setArguments method sets non-default instance" + " of empty Object array for getArgs",
        getArgsField.get(property),
        getArgs);

    Assert.assertSame(
        "setArguments method sets non-default instance" + " of empty Object array for setArgs",
        setArgsField.get(property),
        setArgs);
  }
  @Test
  public void setKeyPreservation() {
    Key key = new Key("key");

    Key duplicateKey1 = new Key("key");
    MutableSet<Key> set1 =
        UnifiedSetWithHashingStrategy.newSet(HashingStrategies.<Key>defaultStrategy())
            .with(key, duplicateKey1);
    Verify.assertSize(1, set1);
    Verify.assertContains(key, set1);
    Assert.assertSame(key, set1.getFirst());

    Key duplicateKey2 = new Key("key");
    MutableSet<Key> set2 =
        UnifiedSetWithHashingStrategy.newSet(HashingStrategies.<Key>defaultStrategy())
            .with(key, duplicateKey1, duplicateKey2);
    Verify.assertSize(1, set2);
    Verify.assertContains(key, set2);
    Assert.assertSame(key, set2.getFirst());

    Key duplicateKey3 = new Key("key");
    MutableSet<Key> set3 =
        UnifiedSetWithHashingStrategy.newSet(HashingStrategies.<Key>defaultStrategy())
            .with(key, new Key("not a dupe"), duplicateKey3);
    Verify.assertSize(2, set3);
    Verify.assertContainsAll(set3, key, new Key("not a dupe"));
    Assert.assertSame(key, set3.detect(key::equals));
  }
  @Test
  public void testLongConstructor() {
    Rectangle node = new Rectangle(10, 10);
    node.setTranslateX(3);
    node.setTranslateY(2);
    node.setTranslateZ(50);
    Rectangle n1 = new Rectangle(10, 10);
    Rectangle n2 = new Rectangle(10, 10);

    PickResult pickRes = new PickResult(node, new Point3D(15, 25, 100), 33);
    ContextMenuEvent e =
        new ContextMenuEvent(
            n1, n2, ContextMenuEvent.CONTEXT_MENU_REQUESTED, 10, 20, 30, 40, false, pickRes);
    assertSame(n1, e.getSource());
    assertSame(n2, e.getTarget());
    assertSame(ContextMenuEvent.CONTEXT_MENU_REQUESTED, e.getEventType());
    assertEquals(18, e.getX(), 10e-20);
    assertEquals(27, e.getY(), 10e-20);
    assertEquals(150, e.getZ(), 10e-20);
    assertEquals(10, e.getSceneX(), 10e-20);
    assertEquals(20, e.getSceneY(), 10e-20);
    assertEquals(30, e.getScreenX(), 10e-20);
    assertEquals(40, e.getScreenY(), 10e-20);
    assertFalse(e.isKeyboardTrigger());
    assertFalse(e.isConsumed());
    assertSame(pickRes, e.getPickResult());

    e = new ContextMenuEvent(ContextMenuEvent.CONTEXT_MENU_REQUESTED, 10, 20, 30, 40, true, null);
    assertTrue(e.isKeyboardTrigger());
  }
  @Test
  public void put_with_hashingStrategy() {
    UnifiedSetWithHashingStrategy<Person> people =
        UnifiedSetWithHashingStrategy.newSet(
                HashingStrategies.nullSafeHashingStrategy(LAST_NAME_HASHING_STRATEGY), 2)
            .withAll(PEOPLE.castToList());
    // Testing if element already exists, returns the instance in the set
    Assert.assertSame(JOHNSMITH, people.put(new Person("Anything", "Smith")));
    Verify.assertSize(2, people);

    // Testing if the element doesn't exist, returns the element itself
    Person notInSet = new Person("Not", "inSet");
    Assert.assertSame(notInSet, people.put(notInSet));
    Verify.assertSize(3, people);

    // Testing putting a null to force a rehash
    Assert.assertNull(people.put(null));
    Verify.assertSize(4, people);

    // Testing put throws NullPointerException if the hashingStrategy is not null safe
    Verify.assertThrows(
        NullPointerException.class,
        () -> {
          UnifiedSetWithHashingStrategy.newSet(LAST_NAME_HASHING_STRATEGY).put(null);
        });
  }
 @Test
 public void shouldHaveSameByteOrder() {
   ByteBuf buf = Unpooled.buffer(1);
   assertSame(Unpooled.BIG_ENDIAN, Unpooled.unmodifiableBuffer(buf).order());
   buf = buf.order(LITTLE_ENDIAN);
   assertSame(Unpooled.LITTLE_ENDIAN, Unpooled.unmodifiableBuffer(buf).order());
 }
  /** Tests nextElement() method. */
  @Test
  public void testNextElement() {
    List<TransactionJobDescriptorEntry> entries = new ArrayList<TransactionJobDescriptorEntry>();
    final TransactionJobDescriptorEntryImpl jobDescriptorEntry1 =
        new TransactionJobDescriptorEntryImpl();
    final TransactionJobDescriptorEntryImpl jobDescriptorEntry2 =
        new TransactionJobDescriptorEntryImpl();
    final TransactionJobDescriptorEntryImpl jobDescriptorEntry3 =
        new TransactionJobDescriptorEntryImpl();
    entries.add(jobDescriptorEntry1);
    entries.add(jobDescriptorEntry2);
    entries.add(jobDescriptorEntry3);

    entryIterator.initialize(entries, Arrays.asList(("2")));
    Assert.assertTrue(entryIterator.hasNextElement());

    final List<TransactionJobDescriptorEntry> nextElement1 = entryIterator.nextElement();
    Assert.assertEquals(2, nextElement1.size());
    Assert.assertSame(jobDescriptorEntry1, nextElement1.get(0));
    Assert.assertSame(jobDescriptorEntry2, nextElement1.get(1));
    Assert.assertTrue(entryIterator.hasNextElement());

    final List<TransactionJobDescriptorEntry> nextElement2 = entryIterator.nextElement();
    Assert.assertEquals(1, nextElement2.size());
    Assert.assertSame(jobDescriptorEntry3, nextElement2.get(0));

    Assert.assertFalse(entryIterator.hasNextElement());
  }
  @Test
  public void testRemoveAndClear() throws Exception {
    IntrabandPortalCacheManager<String, String> intraBandPortalCacheManager =
        new IntrabandPortalCacheManager<String, String>(_mockRegistrationReference);

    String portalCacheName1 = "portalCacheName1";

    PortalCache<?, ?> portalCache1 = intraBandPortalCacheManager.getCache(portalCacheName1);

    String portalCacheName2 = "portalCacheName2";

    PortalCache<?, ?> portalCache2 = intraBandPortalCacheManager.getCache(portalCacheName2);

    Map<String, PortalCache<?, ?>> portalCaches = getPortalCaches(intraBandPortalCacheManager);

    Assert.assertEquals(2, portalCaches.size());
    Assert.assertSame(portalCache1, portalCaches.get(portalCacheName1));
    Assert.assertSame(portalCache2, portalCaches.get(portalCacheName2));

    intraBandPortalCacheManager.removeCache(portalCacheName1);

    Assert.assertEquals(1, portalCaches.size());
    Assert.assertSame(portalCache2, portalCaches.get(portalCacheName2));

    intraBandPortalCacheManager.clearAll();

    Assert.assertTrue(portalCaches.isEmpty());
  }
Example #29
0
  @Test
  public void extend_overrideField() throws Exception {
    field3.setName("field1"); // group2.field1 overrides group1.field1

    group1 = new GroupConfigImpl();
    group1.setName("group1");
    group1.setFieldConfigImplList(createFieldList(field1));
    group1.afterPropertiesSet();

    group2 = new GroupConfigImpl();
    group2.setName("group2");
    group2.setFieldConfigImplList(createFieldList(field2, field3));
    group2.setParentGroup("group1");
    group2.afterPropertiesSet();

    formConfig.setGroupConfigImplList(createGroupList(group1, group2));
    formConfig.afterPropertiesSet();

    assertEquals(1, group1.getFieldConfigList().size());
    assertSame(field1, group1.getFieldConfig("field1"));

    assertEquals(2, group2.getFieldConfigList().size());
    assertSame(field3, group2.getFieldConfig("field1"));
    assertSame(field2, group2.getFieldConfig("field2"));
  }
  /** Test of constructors of class CategoryBalancedBaggingLearner. */
  @Test
  public void testConstructors() {
    Perceptron learner = null;
    double percentToSample = BaggingCategorizerLearner.DEFAULT_PERCENT_TO_SAMPLE;
    int maxIterations = BaggingCategorizerLearner.DEFAULT_MAX_ITERATIONS;
    CategoryBalancedBaggingLearner<Vector, Boolean> instance =
        new CategoryBalancedBaggingLearner<Vector, Boolean>();
    assertSame(learner, instance.getLearner());
    assertEquals(percentToSample, instance.getPercentToSample(), 0.0);
    assertEquals(maxIterations, instance.getMaxIterations());
    assertNotNull(instance.getRandom());

    learner = new Perceptron();
    instance = new CategoryBalancedBaggingLearner<Vector, Boolean>(learner);
    assertSame(learner, instance.getLearner());
    assertEquals(percentToSample, instance.getPercentToSample(), 0.0);
    assertEquals(maxIterations, instance.getMaxIterations());
    assertNotNull(instance.getRandom());

    percentToSample = percentToSample / 3.4;
    maxIterations = maxIterations * 9;
    instance =
        new CategoryBalancedBaggingLearner<Vector, Boolean>(
            learner, maxIterations, percentToSample, random);
    assertSame(learner, instance.getLearner());
    assertEquals(percentToSample, instance.getPercentToSample(), 0.0);
    assertEquals(maxIterations, instance.getMaxIterations());
    assertSame(random, instance.getRandom());
  }