public static IMatcher<int?> BetweenIncluding(int expectFrom, int expectTo) { return Matchers.Function((int? actual) => actual != null && actual >= expectFrom && actual <= expectTo, "an integer where " + expectFrom + " <= value <= " + expectTo); }
public void ExpectTo_should_obtain_matcher() { Assert.IsInstanceOf <HaveKeyMatcher <int> >(Matchers.HaveKey(1)); }
public static IMatcher<int?> GreaterOrEqualTo(int expect) { return Matchers.Function((int? actual) => actual != null && actual >= expect, "an integer >= " + expect); }
public static IMatcher<int?> Not(int expect) { return Matchers.Function((int? actual) => actual != null && actual != expect, "an integer != " + expect); }
private Matcher <string> IndexRecoveryLogMatcher(string logMessage, string subIndexProviderKey) { return(Matchers.stringContainsInOrder(Iterables.asIterable(logMessage, "descriptor", "indexFile=", File.separator + subIndexProviderKey))); }
public static IMatcher<int?> EqualTo(int expect) { return Matchers.Function((int? actual) => actual.Equals(expect), "an integer == " + expect); }
protected override ITestMatcher <IEnumerable <T> > CreateMatcher <T>(IEnumerable <T> expected) { return(Matchers.BeSetEqualTo <T>(expected)); }
/// <exception cref="System.Exception"/> public virtual void TestOutOfOrder() { Log.Info("STARTING testOutOfOrder"); AppContext mockContext = Org.Mockito.Mockito.Mock <AppContext>(); EventHandler mockEventHandler = Org.Mockito.Mockito.Mock <EventHandler>(); Org.Mockito.Mockito.When(mockContext.GetEventHandler()).ThenReturn(mockEventHandler ); TestContainerLauncherImpl.ContainerManagementProtocolClient mockCM = Org.Mockito.Mockito.Mock <TestContainerLauncherImpl.ContainerManagementProtocolClient>(); TestContainerLauncherImpl.ContainerLauncherImplUnderTest ut = new TestContainerLauncherImpl.ContainerLauncherImplUnderTest (mockContext, mockCM); Configuration conf = new Configuration(); ut.Init(conf); ut.Start(); try { ContainerId contId = MakeContainerId(0l, 0, 0, 1); TaskAttemptId taskAttemptId = MakeTaskAttemptId(0l, 0, 0, TaskType.Map, 0); string cmAddress = "127.0.0.1:8000"; StartContainersResponse startResp = recordFactory.NewRecordInstance <StartContainersResponse >(); startResp.SetAllServicesMetaData(serviceResponse); Log.Info("inserting cleanup event"); ContainerLauncherEvent mockCleanupEvent = Org.Mockito.Mockito.Mock <ContainerLauncherEvent >(); Org.Mockito.Mockito.When(mockCleanupEvent.GetType()).ThenReturn(ContainerLauncher.EventType .ContainerRemoteCleanup); Org.Mockito.Mockito.When(mockCleanupEvent.GetContainerID()).ThenReturn(contId); Org.Mockito.Mockito.When(mockCleanupEvent.GetTaskAttemptID()).ThenReturn(taskAttemptId ); Org.Mockito.Mockito.When(mockCleanupEvent.GetContainerMgrAddress()).ThenReturn(cmAddress ); ut.Handle(mockCleanupEvent); ut.WaitForPoolToIdle(); Org.Mockito.Mockito.Verify(mockCM, Org.Mockito.Mockito.Never()).StopContainers(Matchers.Any <StopContainersRequest>()); Log.Info("inserting launch event"); ContainerRemoteLaunchEvent mockLaunchEvent = Org.Mockito.Mockito.Mock <ContainerRemoteLaunchEvent >(); Org.Mockito.Mockito.When(mockLaunchEvent.GetType()).ThenReturn(ContainerLauncher.EventType .ContainerRemoteLaunch); Org.Mockito.Mockito.When(mockLaunchEvent.GetContainerID()).ThenReturn(contId); Org.Mockito.Mockito.When(mockLaunchEvent.GetTaskAttemptID()).ThenReturn(taskAttemptId ); Org.Mockito.Mockito.When(mockLaunchEvent.GetContainerMgrAddress()).ThenReturn(cmAddress ); Org.Mockito.Mockito.When(mockCM.StartContainers(Matchers.Any <StartContainersRequest >())).ThenReturn(startResp); Org.Mockito.Mockito.When(mockLaunchEvent.GetContainerToken()).ThenReturn(CreateNewContainerToken (contId, cmAddress)); ut.Handle(mockLaunchEvent); ut.WaitForPoolToIdle(); Org.Mockito.Mockito.Verify(mockCM, Org.Mockito.Mockito.Never()).StartContainers(Matchers.Any <StartContainersRequest>()); } finally { ut.Stop(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void crashAndRebuildSlowWithDynamicStringDeletions() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void CrashAndRebuildSlowWithDynamicStringDeletions() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.internal.GraphDatabaseAPI db = (org.neo4j.kernel.internal.GraphDatabaseAPI) new org.neo4j.test.TestGraphDatabaseFactory().setFileSystem(fs.get()).newImpermanentDatabaseBuilder(testDir.databaseDir()).setConfig(org.neo4j.graphdb.factory.GraphDatabaseSettings.record_id_batch_size, "1").newGraphDatabase(); GraphDatabaseAPI db = ( GraphDatabaseAPI )(new TestGraphDatabaseFactory()).setFileSystem(Fs.get()).newImpermanentDatabaseBuilder(TestDir.databaseDir()).setConfig(GraphDatabaseSettings.record_id_batch_size, "1").newGraphDatabase(); IList <long> deletedNodeIds = ProduceNonCleanDefraggedStringStore(db); IDictionary <IdType, long> highIdsBeforeCrash = GetHighIds(db); // Make sure all of our changes are actually written to the files, since any background flushing could // mess up the check-sums in non-deterministic ways Db.DependencyResolver.resolveDependency(typeof(PageCache)).flushAndForce(); long checksumBefore = Fs.get().checksum(); long checksumBefore2 = Fs.get().checksum(); assertThat(checksumBefore, Matchers.equalTo(checksumBefore2)); EphemeralFileSystemAbstraction snapshot = Fs.snapshot(Db.shutdown); long snapshotChecksum = snapshot.Checksum(); if (snapshotChecksum != checksumBefore) { using (Stream @out = new FileStream(TestDir.file("snapshot.zip"), FileMode.Create, FileAccess.Write)) { snapshot.DumpZip(@out); } using (Stream @out = new FileStream(TestDir.file("fs.zip"), FileMode.Create, FileAccess.Write)) { Fs.get().dumpZip(@out); } } assertThat(snapshotChecksum, equalTo(checksumBefore)); // Recover with unsupported.dbms.id_generator_fast_rebuild_enabled=false AssertNumberOfFreeIdsEquals(TestDir.databaseDir(), snapshot, 0); GraphDatabaseAPI newDb = ( GraphDatabaseAPI )(new TestGraphDatabaseFactory()).setFileSystem(snapshot).newImpermanentDatabaseBuilder(TestDir.databaseDir()).setConfig(GraphDatabaseSettings.rebuild_idgenerators_fast, FALSE).newGraphDatabase(); IDictionary <IdType, long> highIdsAfterCrash = GetHighIds(newDb); assertEquals(highIdsBeforeCrash, highIdsAfterCrash); try { using (Transaction tx = newDb.BeginTx()) { // Verify that the data we didn't delete is still around int nameCount = 0; int relCount = 0; foreach (Node node in newDb.AllNodes) { nameCount++; assertThat(node, inTx(newDb, hasProperty("name"), true)); relCount += ( int )Iterables.count(node.GetRelationships(Direction.OUTGOING)); } assertEquals(16, nameCount); assertEquals(12, relCount); // Verify that the ids of the nodes we deleted are reused IList <long> newIds = new List <long>(); newIds.Add(newDb.CreateNode().Id); newIds.Add(newDb.CreateNode().Id); newIds.Add(newDb.CreateNode().Id); newIds.Add(newDb.CreateNode().Id); assertThat(newIds, @is(deletedNodeIds)); tx.Success(); } } finally { newDb.Shutdown(); snapshot.Dispose(); } }
/// <exception cref="System.Exception"/> private void TestTriggerBlockReport(bool incremental) { Configuration conf = new HdfsConfiguration(); // Set a really long value for dfs.blockreport.intervalMsec and // dfs.heartbeat.interval, so that incremental block reports and heartbeats // won't be sent during this test unless they're triggered // manually. conf.SetLong(DFSConfigKeys.DfsBlockreportIntervalMsecKey, 10800000L); conf.SetLong(DFSConfigKeys.DfsHeartbeatIntervalKey, 1080L); MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(1).Build(); cluster.WaitActive(); FileSystem fs = cluster.GetFileSystem(); DatanodeProtocolClientSideTranslatorPB spy = DataNodeTestUtils.SpyOnBposToNN(cluster .GetDataNodes()[0], cluster.GetNameNode()); DFSTestUtil.CreateFile(fs, new Path("/abc"), 16, (short)1, 1L); // We should get 1 incremental block report. Org.Mockito.Mockito.Verify(spy, Org.Mockito.Mockito.Timeout(60000).Times(1)).BlockReceivedAndDeleted (Matchers.Any <DatanodeRegistration>(), Matchers.AnyString(), Matchers.Any <StorageReceivedDeletedBlocks []>()); // We should not receive any more incremental or incremental block reports, // since the interval we configured is so long. for (int i = 0; i < 3; i++) { Sharpen.Thread.Sleep(10); Org.Mockito.Mockito.Verify(spy, Org.Mockito.Mockito.Times(0)).BlockReport(Matchers.Any <DatanodeRegistration>(), Matchers.AnyString(), Matchers.Any <StorageBlockReport[] >(), Org.Mockito.Mockito.AnyObject <BlockReportContext>()); Org.Mockito.Mockito.Verify(spy, Org.Mockito.Mockito.Times(1)).BlockReceivedAndDeleted (Matchers.Any <DatanodeRegistration>(), Matchers.AnyString(), Matchers.Any <StorageReceivedDeletedBlocks []>()); } // Create a fake block deletion notification on the DataNode. // This will be sent with the next incremental block report. ReceivedDeletedBlockInfo rdbi = new ReceivedDeletedBlockInfo(new Block(5678, 512, 1000), ReceivedDeletedBlockInfo.BlockStatus.DeletedBlock, null); DataNode datanode = cluster.GetDataNodes()[0]; BPServiceActor actor = datanode.GetAllBpOs()[0].GetBPServiceActors()[0]; string storageUuid = datanode.GetFSDataset().GetVolumes()[0].GetStorageID(); actor.NotifyNamenodeDeletedBlock(rdbi, storageUuid); // Manually trigger a block report. datanode.TriggerBlockReport(new BlockReportOptions.Factory().SetIncremental(incremental ).Build()); // triggerBlockReport returns before the block report is // actually sent. Wait for it to be sent here. if (incremental) { Org.Mockito.Mockito.Verify(spy, Org.Mockito.Mockito.Timeout(60000).Times(2)).BlockReceivedAndDeleted (Matchers.Any <DatanodeRegistration>(), Matchers.AnyString(), Matchers.Any <StorageReceivedDeletedBlocks []>()); } else { Org.Mockito.Mockito.Verify(spy, Org.Mockito.Mockito.Timeout(60000)).BlockReport(Matchers.Any <DatanodeRegistration>(), Matchers.AnyString(), Matchers.Any <StorageBlockReport[] >(), Org.Mockito.Mockito.AnyObject <BlockReportContext>()); } cluster.Shutdown(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("WeakerAccess") public void assertBuffer(Object... writeEvents) public virtual void AssertBuffer(params object[] writeEvents) { assertThat(Buffer, Matchers.contains(writeEvents)); }
private void StubQueueAllocation(CSQueue queue, Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource, FiCaSchedulerNode node, int allocation, NodeType type) { // Simulate the queue allocation Org.Mockito.Mockito.DoAnswer(new _Answer_137(this, queue, allocation, node, clusterResource , type)).When(queue).AssignContainers(Matchers.Eq(clusterResource), Matchers.Eq( node), Matchers.Any <ResourceLimits>()); }
private ResourceLimits AnyResourceLimits() { return(Matchers.Any <ResourceLimits>()); }
public virtual void TestOffSwitchSchedulingMultiLevelQueues() { // Setup queue configs SetupMultiLevelQueues(csConf); //B3 IDictionary <string, CSQueue> queues = new Dictionary <string, CSQueue>(); CSQueue root = CapacityScheduler.ParseQueue(csContext, csConf, null, CapacitySchedulerConfiguration .Root, queues, queues, TestUtils.spyHook); // Setup some nodes int memoryPerNode = 10; int coresPerNode = 10; int numNodes = 2; FiCaSchedulerNode node_0 = TestUtils.GetMockNode("host_0", DefaultRack, 0, memoryPerNode * Gb); FiCaSchedulerNode node_1 = TestUtils.GetMockNode("host_1", DefaultRack, 0, memoryPerNode * Gb); Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource = Resources.CreateResource (numNodes * (memoryPerNode * Gb), numNodes * coresPerNode); Org.Mockito.Mockito.When(csContext.GetNumClusterNodes()).ThenReturn(numNodes); // Start testing LeafQueue b3 = (LeafQueue)queues[B3]; LeafQueue b2 = (LeafQueue)queues[B2]; // Simulate B3 returning a container on node_0 StubQueueAllocation(b2, clusterResource, node_0, 0 * Gb, NodeType.OffSwitch); StubQueueAllocation(b3, clusterResource, node_0, 1 * Gb, NodeType.OffSwitch); root.AssignContainers(clusterResource, node_0, new ResourceLimits(clusterResource )); VerifyQueueMetrics(b2, 0 * Gb, clusterResource); VerifyQueueMetrics(b3, 1 * Gb, clusterResource); // Now, B2 should get the scheduling opportunity since B2=0G/2G, B3=1G/7G // also, B3 gets a scheduling opportunity since B2 allocates RACK_LOCAL StubQueueAllocation(b2, clusterResource, node_1, 1 * Gb, NodeType.RackLocal); StubQueueAllocation(b3, clusterResource, node_1, 1 * Gb, NodeType.OffSwitch); root.AssignContainers(clusterResource, node_1, new ResourceLimits(clusterResource )); InOrder allocationOrder = Org.Mockito.Mockito.InOrder(b2, b3); allocationOrder.Verify(b2).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); allocationOrder.Verify(b3).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); VerifyQueueMetrics(b2, 1 * Gb, clusterResource); VerifyQueueMetrics(b3, 2 * Gb, clusterResource); // Now, B3 should get the scheduling opportunity // since B2 has 1/2G while B3 has 2/7G, // However, since B3 returns off-switch, B2 won't get an opportunity StubQueueAllocation(b2, clusterResource, node_0, 1 * Gb, NodeType.NodeLocal); StubQueueAllocation(b3, clusterResource, node_0, 1 * Gb, NodeType.OffSwitch); root.AssignContainers(clusterResource, node_0, new ResourceLimits(clusterResource )); allocationOrder = Org.Mockito.Mockito.InOrder(b3, b2); allocationOrder.Verify(b3).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); allocationOrder.Verify(b2).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); VerifyQueueMetrics(b2, 1 * Gb, clusterResource); VerifyQueueMetrics(b3, 3 * Gb, clusterResource); }
protected override ITestMatcher <IEnumerable <T> > CreateMatcher <T>(IEnumerable <T> expected, Comparison <T> comparison) { return(Matchers.BeSetEqualTo <T>(expected, comparison)); }
public void ExpectTo_should_obtain_matcher() { Assert.IsInstanceOf <HaveKeyWithValueMatcher <int, int> >(Matchers.HaveKeyWithValue(1, 2)); }
protected override ITestMatcher <T> CreateMatcher <T>(T expected) { return(Matchers.BeGreaterThan(expected)); }
public virtual void ExpectedTokenIsRetrievedFromDFS() { byte[] ident = new DelegationTokenIdentifier(new Text("owner"), new Text("renewer" ), new Text("realuser")).GetBytes(); byte[] pw = new byte[] { 42 }; Text service = new Text(uri.ToString()); // Create a token for the fetcher to fetch, wire NN to return it when asked // for this particular user. Org.Apache.Hadoop.Security.Token.Token <DelegationTokenIdentifier> t = new Org.Apache.Hadoop.Security.Token.Token <DelegationTokenIdentifier>(ident, pw, FakeRenewer.Kind, service); Org.Mockito.Mockito.When(dfs.AddDelegationTokens(Matchers.Eq((string)null), Matchers.Any <Credentials>())).ThenAnswer(new _Answer_77(service, t)); Org.Mockito.Mockito.When(dfs.GetUri()).ThenReturn(uri); FakeRenewer.Reset(); FileSystem fileSys = FileSystem.GetLocal(conf); try { DelegationTokenFetcher.Main(new string[] { "-fs", uri.ToString(), tokenFile }); Path p = new Path(fileSys.GetWorkingDirectory(), tokenFile); Credentials creds = Credentials.ReadTokenStorageFile(p, conf); IEnumerator <Org.Apache.Hadoop.Security.Token.Token <object> > itr = creds.GetAllTokens ().GetEnumerator(); // make sure we got back exactly the 1 token we expected NUnit.Framework.Assert.IsTrue(itr.HasNext()); NUnit.Framework.Assert.AreEqual(t, itr.Next()); NUnit.Framework.Assert.IsTrue(!itr.HasNext()); DelegationTokenFetcher.Main(new string[] { "--print", tokenFile }); DelegationTokenFetcher.Main(new string[] { "--renew", tokenFile }); NUnit.Framework.Assert.AreEqual(t, FakeRenewer.lastRenewed); FakeRenewer.Reset(); DelegationTokenFetcher.Main(new string[] { "--cancel", tokenFile }); NUnit.Framework.Assert.AreEqual(t, FakeRenewer.lastCanceled); } finally { fileSys.Delete(new Path(tokenFile), true); } }
protected override ITestMatcher <T> CreateMatcher <T>(T expected, Comparison <T> comparison) { return(Matchers.BeGreaterThan(expected, comparison)); }
private Matcher <string> IndexRecoveryFinishedLogMatcher(string subIndexProviderKey) { return(Matchers.stringContainsInOrder(Iterables.asIterable("Schema index cleanup job finished", "descriptor", "indexFile=", File.separator + subIndexProviderKey, "Number of pages visited", "Number of cleaned crashed pointers", "Time spent"))); }
/// <exception cref="System.IO.IOException"/> private FSNamesystem MakeNameSystemSpy(Block block, INodeFile file) { Configuration conf = new Configuration(); FSImage image = new FSImage(conf); DatanodeStorageInfo[] targets = new DatanodeStorageInfo[] { }; FSNamesystem namesystem = new FSNamesystem(conf, image); namesystem.SetImageLoaded(true); // set file's parent as root and put the file to inodeMap, so // FSNamesystem's isFileDeleted() method will return false on this file if (file.GetParent() == null) { INodeDirectory mparent = Org.Mockito.Mockito.Mock <INodeDirectory>(); INodeDirectory parent = new INodeDirectory(mparent.GetId(), new byte[0], mparent. GetPermissionStatus(), mparent.GetAccessTime()); parent.SetLocalName(new byte[0]); parent.AddChild(file); file.SetParent(parent); } namesystem.dir.GetINodeMap().Put(file); FSNamesystem namesystemSpy = Org.Mockito.Mockito.Spy(namesystem); BlockInfoContiguousUnderConstruction blockInfo = new BlockInfoContiguousUnderConstruction (block, (short)1, HdfsServerConstants.BlockUCState.UnderConstruction, targets); blockInfo.SetBlockCollection(file); blockInfo.SetGenerationStamp(genStamp); blockInfo.InitializeBlockRecovery(genStamp); Org.Mockito.Mockito.DoReturn(true).When(file).RemoveLastBlock(Matchers.Any <Block> ()); Org.Mockito.Mockito.DoReturn(true).When(file).IsUnderConstruction(); Org.Mockito.Mockito.DoReturn(new BlockInfoContiguous[1]).When(file).GetBlocks(); Org.Mockito.Mockito.DoReturn(blockInfo).When(namesystemSpy).GetStoredBlock(Matchers.Any <Block>()); Org.Mockito.Mockito.DoReturn(blockInfo).When(file).GetLastBlock(); Org.Mockito.Mockito.DoReturn(string.Empty).When(namesystemSpy).CloseFileCommitBlocks (Matchers.Any <INodeFile>(), Matchers.Any <BlockInfoContiguous>()); Org.Mockito.Mockito.DoReturn(Org.Mockito.Mockito.Mock <FSEditLog>()).When(namesystemSpy ).GetEditLog(); return(namesystemSpy); }
public static IMatcher<int?> GreaterThan(int expect) { return Matchers.Function((int? actual) => actual != null && actual > expect, "an integer > " + expect); }
private DescriptorMatcher GetNativeMatcher(Matchers matcher) { switch (matcher) { case Matchers.L1: return new BFMatcher(DistanceType.L1); case Matchers.L2: return new BFMatcher(DistanceType.L2); case Matchers.L2Sqr: return new BFMatcher(DistanceType.L2Sqr); default: throw new ArgumentException("Don't know type " + matcher); } }
public static IMatcher<int?> LessThanOrEqualTo(int expect) { return Matchers.Function((int? actual) => actual != null && actual <= expect, "an integer <= " + expect); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void givenClusterWhenMasterGoesDownAndTxIsRunningThenDontWaitToSwitch() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void GivenClusterWhenMasterGoesDownAndTxIsRunningThenDontWaitToSwitch() { ClusterManager clusterManager = (new ClusterManager.Builder(TestDirectory.directory(TestName.MethodName))).withCluster(ClusterManager.clusterOfSize(3)).build(); try { clusterManager.Start(); ClusterManager.ManagedCluster cluster = clusterManager.Cluster; cluster.Await(allSeesAllAsAvailable()); HighlyAvailableGraphDatabase slave = cluster.AnySlave; Transaction tx = slave.BeginTx(); // Do a little write operation so that all "write" aspects of this tx is initializes properly slave.CreateNode(); // Shut down master while we're keeping this transaction open cluster.Shutdown(cluster.Master); cluster.Await(masterAvailable()); cluster.Await(masterSeesSlavesAsAvailable(1)); // Ending up here means that we didn't wait for this transaction to complete tx.Success(); try { tx.Close(); fail("Exception expected"); } catch (Exception e) { assertThat(e, instanceOf(typeof(TransientTransactionFailureException))); Exception rootCause = rootCause(e); assertThat(rootCause, instanceOf(typeof(TransactionTerminatedException))); assertThat((( TransactionTerminatedException )rootCause).status(), Matchers.equalTo(Org.Neo4j.Kernel.Api.Exceptions.Status_General.DatabaseUnavailable)); } } finally { clusterManager.Stop(); } }
public static IMatcher<int?> Between(int expectFrom, int expectTo) { return Matchers.Function((int? actual) => actual != null && actual > expectFrom && actual < expectTo, "an integer where " + expectFrom + " < value < " + expectTo); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testEntityCaching() public virtual void testEntityCaching() { string[] userIds = new string[] { "test" }; // mock user and query User user = mock(typeof(User)); when(user.Id).thenReturn(userIds[0]); when(user.FirstName).thenReturn("kermit"); UserQuery userQuery = mock(typeof(UserQuery)); when(userQuery.userIdIn(Matchers.anyVararg <string[]>())).thenReturn(userQuery); when(userQuery.listPage(anyInt(), anyInt())).thenReturn(Arrays.asList(user)); when(processEngine.IdentityService.createUserQuery()).thenReturn(userQuery); // configure cache HalRelationCacheConfiguration configuration = new HalRelationCacheConfiguration(); configuration.CacheImplementationClass = typeof(DefaultHalResourceCache); IDictionary <string, object> halUserConfig = new Dictionary <string, object>(); halUserConfig["capacity"] = 100; halUserConfig["secondsToLive"] = 10000; configuration.addCacheConfiguration(typeof(HalUser), halUserConfig); contextListener.configureCaches(configuration); // cache exists and is empty DefaultHalResourceCache cache = (DefaultHalResourceCache)Hal.Instance.getHalRelationCache(typeof(HalUser)); assertNotNull(cache); assertEquals(0, cache.size()); // get link resolver and resolve user HalLinkResolver linkResolver = Hal.Instance.getLinkResolver(typeof(UserRestService)); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<org.camunda.bpm.engine.rest.hal.HalResource<?>> halUsers = linkResolver.resolveLinks(userIds, processEngine); IList <HalResource <object> > halUsers = linkResolver.resolveLinks(userIds, processEngine); // mocked user was resolved assertNotNull(halUsers); assertEquals(1, halUsers.Count); HalUser halUser = (HalUser)halUsers[0]; assertEquals("kermit", halUser.FirstName); // cache contains user assertEquals(1, cache.size()); // change user mock when(user.FirstName).thenReturn("fritz"); // resolve users again halUsers = linkResolver.resolveLinks(userIds, processEngine); // cached mocked user was resolved with old name assertNotNull(halUsers); assertEquals(1, halUsers.Count); halUser = (HalUser)halUsers[0]; assertEquals("kermit", halUser.FirstName); forwardTime(cache.SecondsToLive * 3); // resolve users again halUsers = linkResolver.resolveLinks(userIds, processEngine); // new mocked user was resolved with old name assertNotNull(halUsers); assertEquals(1, halUsers.Count); halUser = (HalUser)halUsers[0]; assertEquals("fritz", halUser.FirstName); }
public static IMatcher<int?> NotNull() { return Matchers.Function((int? actual) => actual != null, "a non null integer"); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRunProcedure() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldRunProcedure() { // Given NegotiateBoltV3(); Connection.send(Util.chunk(new RunMessage("CREATE (n:Test {age: 2}) RETURN n.age AS age"), PullAllMessage.INSTANCE)); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: org.hamcrest.Matcher<java.util.Map<? extends String,?>> ageMatcher = hasEntry(is("fields"), equalTo(singletonList("age"))); Matcher <IDictionary <string, ?> > ageMatcher = hasEntry(@is("fields"), equalTo(singletonList("age"))); assertThat(Connection, Util.eventuallyReceives(msgSuccess(allOf(ageMatcher, hasKey("t_first"))), msgRecord(eqRecord(equalTo(longValue(2L)))), msgSuccess())); // When Connection.send(Util.chunk(new RunMessage("CALL db.labels() YIELD label"), PullAllMessage.INSTANCE)); // Then //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: org.hamcrest.Matcher<java.util.Map<? extends String,?>> entryFieldsMatcher = hasEntry(is("fields"), equalTo(singletonList("label"))); Matcher <IDictionary <string, ?> > entryFieldsMatcher = hasEntry(@is("fields"), equalTo(singletonList("label"))); assertThat(Connection, Util.eventuallyReceives(msgSuccess(allOf(entryFieldsMatcher, hasKey("t_first"))), msgRecord(eqRecord(Matchers.equalTo(stringValue("Test")))), msgSuccess())); }
/// <exception cref="System.IO.IOException"/> private static void SetHeartbeatResponse(DatanodeCommand[] cmds) { NNHAStatusHeartbeat ha = new NNHAStatusHeartbeat(HAServiceProtocol.HAServiceState .Active, fsImage.GetLastAppliedOrWrittenTxId()); HeartbeatResponse response = new HeartbeatResponse(cmds, ha, null); Org.Mockito.Mockito.DoReturn(response).When(spyNN).SendHeartbeat((DatanodeRegistration )Matchers.Any(), (StorageReport[])Matchers.Any(), Matchers.AnyLong(), Matchers.AnyLong (), Matchers.AnyInt(), Matchers.AnyInt(), Matchers.AnyInt(), (VolumeFailureSummary )Matchers.Any()); }
public virtual void TestMultiLevelQueues() { /* * Structure of queue: * Root * ____________ * / | \ \ * A B C D * / | / | \ \ * A1 A2 B1 B2 B3 C1 * \ * C11 * \ * C111 * \ * C1111 */ // Setup queue configs SetupMultiLevelQueues(csConf); IDictionary <string, CSQueue> queues = new Dictionary <string, CSQueue>(); CSQueue root = CapacityScheduler.ParseQueue(csContext, csConf, null, CapacitySchedulerConfiguration .Root, queues, queues, TestUtils.spyHook); // Setup some nodes int memoryPerNode = 10; int coresPerNode = 16; int numNodes = 3; FiCaSchedulerNode node_0 = TestUtils.GetMockNode("host_0", DefaultRack, 0, memoryPerNode * Gb); FiCaSchedulerNode node_1 = TestUtils.GetMockNode("host_1", DefaultRack, 0, memoryPerNode * Gb); FiCaSchedulerNode node_2 = TestUtils.GetMockNode("host_2", DefaultRack, 0, memoryPerNode * Gb); Org.Apache.Hadoop.Yarn.Api.Records.Resource clusterResource = Resources.CreateResource (numNodes * (memoryPerNode * Gb), numNodes * coresPerNode); Org.Mockito.Mockito.When(csContext.GetNumClusterNodes()).ThenReturn(numNodes); // Start testing CSQueue a = queues[A]; CSQueue b = queues[B]; CSQueue c = queues[C]; CSQueue d = queues[D]; CSQueue a1 = queues[A1]; CSQueue a2 = queues[A2]; CSQueue b1 = queues[B1]; CSQueue b2 = queues[B2]; CSQueue b3 = queues[B3]; // Simulate C returning a container on node_0 StubQueueAllocation(a, clusterResource, node_0, 0 * Gb); StubQueueAllocation(b, clusterResource, node_0, 0 * Gb); StubQueueAllocation(c, clusterResource, node_0, 1 * Gb); StubQueueAllocation(d, clusterResource, node_0, 0 * Gb); root.AssignContainers(clusterResource, node_0, new ResourceLimits(clusterResource )); VerifyQueueMetrics(a, 0 * Gb, clusterResource); VerifyQueueMetrics(b, 0 * Gb, clusterResource); VerifyQueueMetrics(c, 1 * Gb, clusterResource); VerifyQueueMetrics(d, 0 * Gb, clusterResource); Org.Mockito.Mockito.Reset(a); Org.Mockito.Mockito.Reset(b); Org.Mockito.Mockito.Reset(c); // Now get B2 to allocate // A = 0/3, B = 0/15, C = 1/6, D=0/6 StubQueueAllocation(a, clusterResource, node_1, 0 * Gb); StubQueueAllocation(b2, clusterResource, node_1, 4 * Gb); StubQueueAllocation(c, clusterResource, node_1, 0 * Gb); root.AssignContainers(clusterResource, node_1, new ResourceLimits(clusterResource )); VerifyQueueMetrics(a, 0 * Gb, clusterResource); VerifyQueueMetrics(b, 4 * Gb, clusterResource); VerifyQueueMetrics(c, 1 * Gb, clusterResource); Org.Mockito.Mockito.Reset(a); Org.Mockito.Mockito.Reset(b); Org.Mockito.Mockito.Reset(c); // Now get both A1, C & B3 to allocate in right order // A = 0/3, B = 4/15, C = 1/6, D=0/6 StubQueueAllocation(a1, clusterResource, node_0, 1 * Gb); StubQueueAllocation(b3, clusterResource, node_0, 2 * Gb); StubQueueAllocation(c, clusterResource, node_0, 2 * Gb); root.AssignContainers(clusterResource, node_0, new ResourceLimits(clusterResource )); InOrder allocationOrder = Org.Mockito.Mockito.InOrder(a, c, b); allocationOrder.Verify(a).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); allocationOrder.Verify(c).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); allocationOrder.Verify(b).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); VerifyQueueMetrics(a, 1 * Gb, clusterResource); VerifyQueueMetrics(b, 6 * Gb, clusterResource); VerifyQueueMetrics(c, 3 * Gb, clusterResource); Org.Mockito.Mockito.Reset(a); Org.Mockito.Mockito.Reset(b); Org.Mockito.Mockito.Reset(c); // Now verify max-capacity // A = 1/3, B = 6/15, C = 3/6, D=0/6 // Ensure a1 won't alloc above max-cap although it should get // scheduling opportunity now, right after a2 Log.Info("here"); ((ParentQueue)a).SetMaxCapacity(.1f); // a should be capped at 3/30 StubQueueAllocation(a1, clusterResource, node_2, 1 * Gb); // shouldn't be // allocated due // to max-cap StubQueueAllocation(a2, clusterResource, node_2, 2 * Gb); StubQueueAllocation(b3, clusterResource, node_2, 1 * Gb); StubQueueAllocation(b1, clusterResource, node_2, 1 * Gb); StubQueueAllocation(c, clusterResource, node_2, 1 * Gb); root.AssignContainers(clusterResource, node_2, new ResourceLimits(clusterResource )); allocationOrder = Org.Mockito.Mockito.InOrder(a, a2, a1, b, c); allocationOrder.Verify(a).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); allocationOrder.Verify(a2).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); allocationOrder.Verify(b).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); allocationOrder.Verify(c).AssignContainers(Matchers.Eq(clusterResource), Matchers.Any <FiCaSchedulerNode>(), AnyResourceLimits()); VerifyQueueMetrics(a, 3 * Gb, clusterResource); VerifyQueueMetrics(b, 8 * Gb, clusterResource); VerifyQueueMetrics(c, 4 * Gb, clusterResource); Org.Mockito.Mockito.Reset(a); Org.Mockito.Mockito.Reset(b); Org.Mockito.Mockito.Reset(c); }