@Test public void test1InitialState() { int count = dao.getCount(TEST_NAME); assertEquals("New TestEntity should have count=0.", 0, count); }
@Test(dependsOnGroups = {"before"}) public void verify() { String[] expected = { "initApplication", "initDialog", "initDialog2", "test", "tearDownDialog2", "tearDownDialog", "tearDownApplication" }; int i = 0; List<String> l = ZBase_0.getMethodList(); AssertJUnit.assertEquals(expected.length, l.size()); for (String s : l) { AssertJUnit.assertEquals(expected[i++], s); } } }
@Test public void testIterableParWithSingletonList() throws InterruptedException { final String valueStr = "value"; final Task<String> task = value("value", valueStr); final Task<List<String>> par = par(Collections.singleton(task)); runAndWait("TestParTask.testIterableParWithSingletonList", par); assertEquals(1, par.get().size()); assertEquals(valueStr, par.get().get(0)); assertEquals(valueStr, task.get()); }
@Test(expectedExceptions = IllegalStateException.class, expectedExceptionsMessageRegExp = "Aggregation SUM cannot be applied to property of type java.lang.String") public void testGroupBy6() { QueryFactory qf = getQueryFactory(); Query q = qf.from(getModelFactory().getUserImplClass()) .select(sum("name")) .build(); List<Object[]> list = q.list(); assertEquals(1, list.size()); assertEquals(1, list.get(0).length); assertEquals(2, list.get(0)[0]); }
public void testForEach() { cache.put("A", "B"); cache.put("C", "D"); List<String> values = new ArrayList<>(); BiConsumer<? super Object, ? super Object> collectKeyValues = (k, v) -> values.add("hello_" + k.toString() + v.toString()); cache.forEach(collectKeyValues); assertEquals(2, values.size()); assertEquals("hello_AB", values.get(0)); assertEquals("hello_CD", values.get(1)); }
@Override protected void createCacheManagers() throws Throwable { super.INIT_CLUSTER_SIZE = 2; super.createCacheManagers(); assertEquals(2, topology(caches.get(0).getCacheManager()).size()); assertEquals(2, topology(caches.get(1).getCacheManager()).size()); cache(0, cacheName).put("k", "v"); assertEquals("v", cache(0, cacheName).get("k")); assertEquals("v", cache(1, cacheName).get("k")); keyAffinityService = (KeyAffinityServiceImpl<Object>) KeyAffinityServiceFactory.newKeyAffinityService(manager(0).getCache(cacheName), executor, new RndKeyGenerator(), 100); }
public void testObjCollect() { Cache<Integer, String> cache = getCache(0); int range = 10; // First populate the cache with a bunch of values IntStream.range(0, range).boxed().forEach(i -> cache.put(i, i + "-value")); assertEquals(range, cache.size()); CacheSet<Map.Entry<Integer, String>> entrySet = cache.entrySet(); List<Map.Entry<Integer, String>> list = createStream(entrySet).collect(ArrayList::new, ArrayList::add, ArrayList::addAll); assertEquals(cache.size(), list.size()); list.parallelStream().forEach(e -> assertEquals(cache.get(e.getKey()), e.getValue())); }
@Test public final void testDeserializeBuffer () { final BinaryDataSegment dataSegment = new BinaryDataSegment(CHUNK_SIZE); assertNotNull(dataSegment); assertEquals(0, dataSegment.getLength()); final ByteBuffer testBuffer = ByteBuffer.wrap(TEST_CASE_1_ARRAY); dataSegment.deserialize(testBuffer, TEST_CASE_1_ARRAY.length); assertEquals(TEST_CASE_1_ARRAY.length, dataSegment.getLength()); final ByteBuffer expectedResult = ByteBuffer.wrap(TEST_CASE_1_ARRAY_LONG); dataSegment.dataBuffer.rewind(); assertTrue(expectedResult.equals(dataSegment.dataBuffer)); }
@Test public void testTryRunWithinCapacity() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(0); Task<?>[] tasks = new Task<?>[10]; for (int i = 0; i < 10; i++) { tasks[i] = Task.action(counter::incrementAndGet); } for (int i = 0; i < 10; i++) { assertTrue(_engine.tryRun(tasks[i], (i % 2 == 0) ? "evenPlan" : "oddPlan")); } assertTrue(awaitAll(tasks)); assertEquals(10, counter.get()); }
public void testL1GetAndCacheEntryGet() { final Cache<Object, String>[] owners = getOwners(key, 2); final Cache<Object, String> ownerCache = owners[0]; final Cache<Object, String> nonOwnerCache = getFirstNonOwner(key); ownerCache.put(key, firstValue); assertEquals(firstValue, nonOwnerCache.get(key)); assertIsInL1(nonOwnerCache, key); CacheEntry<Object, String> entry = nonOwnerCache.getAdvancedCache().getCacheEntry(key); assertEquals(key, entry.getKey()); assertEquals(firstValue, entry.getValue()); }
private void initAndCheck(Method m) { cache(0).put(key, m.getName()); assertEquals(m.getName(), cache(1).get(key)); assertEquals(m.getName(), cache(2).get(key)); }
public void testRollbackSpanningCaches2() throws Exception { startAllCaches(); Cache<String, String> c1 = cache(0, "c1"); assertTrue(c1.getCacheConfiguration().clustering().cacheMode().isClustered()); Cache<String, String> c1Replica = cache(1, "c1"); assertTrue(c1.isEmpty()); assertTrue(c1Replica.isEmpty()); c1.put("c1key", "c1value"); assertEquals(c1.get("c1key"), "c1value"); assertEquals(c1Replica.get("c1key"), "c1value"); }
public void testGetOnlyQueriesCacheOnOwners() throws PersistenceException { // Make a key that own'ers is c1 and c2 final MagicKey k = getMagicKey(); final String v1 = "real-data"; final String v2 = "stale-data"; // Simulate c3 was by itself and someone wrote a value that is now stale CacheWriter store = (CacheWriter) TestingUtil.getFirstLoader(c3); store.write(new MarshalledEntryImpl(k, v2, null, extractGlobalMarshaller(c3.getCacheManager()))); c1.put(k, v1); assertEquals(v1, c3.get(k)); }
private void verifyShallowTrace(final Task<?> task) { final ShallowTrace trace = findPossiblyFusedTrace(task); assertEquals(task.getName(), trace.getName()); assertEquals(ResultType.fromTask(task), trace.getResultType()); } else { assertTrue(trace.getEndNanos() <= System.nanoTime()); assertTrue(trace.getEndNanos() > trace.getStartNanos()); assertNotNull(trace.getValue()); } else { assertNull(trace.getValue());
public void testPutFromNonOwner() throws Exception { Cache<Object, String> cacheX = getFirstNonOwner("key1"); CacheLoader storeX = TestingUtil.getFirstLoader(cacheX); cacheX.put("key1", "v1"); assertEquals("v1", cacheX.get("key1")); assertNotNull(storeX.load("key1")); assertEquals("v1", storeX.load("key1").getValue()); }
private <T> void assertDone(final Task<T> task, final T expectedValue) { assertTrue(task.isDone()); assertFalse(task.isFailed()); assertEquals(expectedValue, task.get()); assertNull(task.getError()); assertTrue(task.getShallowTrace().getStartNanos() > 0); assertTrue(task.getShallowTrace().getStartNanos() <= task.getShallowTrace().getEndNanos()); }
public void testPutIfAbsentLockCleanup() { assertNoLocks(cache); cache.put("key", "value"); assertNoLocks(cache); // This call should fail. cache.putForExternalRead("key", "value2"); assertNoLocks(cache); assertEquals("value", cache.get("key")); }
public void testGlobalAvg() { QueryFactory qf = getQueryFactory(); Query q = qf.from(getModelFactory().getTransactionImplClass()) .select(avg("amount")) .build(); List<Object[]> list = q.list(); assertEquals(1, list.size()); assertEquals(1, list.get(0).length); assertEquals(173.0892d, (Double) list.get(0)[0], 0.0001d); }
@SuppressWarnings("deprecation") @Test public void testParWithGeneralType() throws InterruptedException { final Integer intVal = 123; final Double dblVal = 456.789; final Task<Integer> intTask = value("intTask", intVal); final Task<Double> dblTask = value("dblTask", dblVal); final ParTask<? extends Number> par = par(intTask, dblTask); runAndWait("TestParTask.testParWithGeneralType", par); assertEquals(2, par.get().size()); assertEquals(intVal, par.get().get(0)); assertEquals(dblVal, par.get().get(1)); }
@Test public void testGetMonitors() throws Exception { List<Monitor<?>> monitors = ((CompositeMonitor<?>) newInstance("test")).getMonitors(); assertEquals(monitors.size(), 2); Monitor<Long> duration = getDuration(monitors); Monitor<Long> activeTasks = getActiveTasks(monitors); assertEquals(duration.getConfig().getName(), "test.duration"); assertEquals(activeTasks.getConfig().getName(), "test.activeTasks"); assertEquals(duration.getValue().longValue(), 0L); assertEquals(activeTasks.getValue().longValue(), 0L); }