You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@storm.apache.org by bo...@apache.org on 2018/01/08 21:20:55 UTC
[2/6] storm git commit: Split up NormalizedResources into a few
classes with more narrow responsibilities. Make NormalizedResources a regular
class instead of an abstract class. Add some tests. Make calculateAvg/Min
throw exceptions if the resource total
http://git-wip-us.apache.org/repos/asf/storm/blob/41db23fe/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/NormalizedResourcesTest.java
----------------------------------------------------------------------
diff --git a/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/NormalizedResourcesTest.java b/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/NormalizedResourcesTest.java
new file mode 100644
index 0000000..d25e76c
--- /dev/null
+++ b/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/NormalizedResourcesTest.java
@@ -0,0 +1,404 @@
+/*
+ * Copyright 2018 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.storm.scheduler.resource.normalization;
+
+import org.apache.storm.scheduler.resource.NormalizedResources;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import org.apache.storm.Constants;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class NormalizedResourcesTest {
+
+ @Rule
+ public NormalizedResourcesRule normalizedResourcesRule = new NormalizedResourcesRule();
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
+ private final String gpuResourceName = "gpu";
+
+ private Map<String, Double> normalize(Map<String, ? extends Number> resources) {
+ return NormalizedResources.RESOURCE_NAME_NORMALIZER.normalizedResourceMap(resources);
+ }
+
+ @Test
+ public void testAddCpu() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+ NormalizedResources addedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ resources.add(addedResources);
+
+ Map<String, Double> normalizedMap = resources.toNormalizedMap();
+ assertThat(normalizedMap.get(Constants.COMMON_CPU_RESOURCE_NAME), is(2.0));
+ assertThat(resources.getTotalCpu(), is(2.0));
+ }
+
+ @Test
+ public void testAddToExistingResource() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+ NormalizedResources addedResources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+
+ resources.add(addedResources);
+
+ Map<String, Double> normalizedMap = resources.toNormalizedMap();
+ assertThat(normalizedMap.get(gpuResourceName), is(2.0));
+ }
+
+ @Test
+ public void testAddWhenOtherHasMoreResourcesThanThis() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.emptyMap()));
+ NormalizedResources addedResources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+
+ resources.add(addedResources);
+
+ Map<String, Double> normalizedMap = resources.toNormalizedMap();
+ assertThat(normalizedMap.get(gpuResourceName), is(1.0));
+ }
+
+ @Test
+ public void testAddWhenOtherHasDifferentResourceThanThis() {
+ String disks = "disks";
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(disks, 23)));
+ NormalizedResources addedResources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+
+ resources.add(addedResources);
+
+ Map<String, Double> normalizedMap = resources.toNormalizedMap();
+ assertThat(normalizedMap.get(disks), is(23.0));
+ assertThat(normalizedMap.get(gpuResourceName), is(1.0));
+ }
+
+ @Test
+ public void testRemoveThrowsIfResourcesBecomeNegative() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+ NormalizedResources removedResources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 2)));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.remove(removedResources);
+ }
+
+ @Test
+ public void testRemoveThrowsIfCpuBecomesNegative() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+ NormalizedResources removedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.remove(removedResources);
+ }
+
+ @Test
+ public void testRemoveFromCpu() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources removedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ resources.remove(removedResources);
+
+ Map<String, Double> normalizedMap = resources.toNormalizedMap();
+ assertThat(normalizedMap.get(Constants.COMMON_CPU_RESOURCE_NAME), is(1.0));
+ assertThat(resources.getTotalCpu(), is(1.0));
+ }
+
+ @Test
+ public void testRemoveFromExistingResources() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 15)));
+ NormalizedResources removedResources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+
+ resources.remove(removedResources);
+
+ Map<String, Double> normalizedMap = resources.toNormalizedMap();
+ assertThat(normalizedMap.get(gpuResourceName), is(14.0));
+ }
+
+ @Test
+ public void testCouldHoldWithTooFewCpus() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+ NormalizedResources resourcesToCheck = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+
+ boolean couldHold = resources.couldHoldIgnoringSharedMemory(resourcesToCheck, 100, 1);
+
+ assertThat(couldHold, is(false));
+ }
+
+ @Test
+ public void testCouldHoldWithTooFewResource() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+ NormalizedResources resourcesToCheck = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 2)));
+
+ boolean couldHold = resources.couldHoldIgnoringSharedMemory(resourcesToCheck, 100, 1);
+
+ assertThat(couldHold, is(false));
+ }
+
+ @Test
+ public void testCouldHoldWithTooLittleMemory() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+ NormalizedResources resourcesToCheck = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+
+ boolean couldHold = resources.couldHoldIgnoringSharedMemory(resourcesToCheck, 100, 200);
+
+ assertThat(couldHold, is(false));
+ }
+
+ @Test
+ public void testCouldHoldWithMissingResource() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.emptyMap()));
+ NormalizedResources resourcesToCheck = new NormalizedResources(normalize(Collections.singletonMap(gpuResourceName, 1)));
+
+ boolean couldHold = resources.couldHoldIgnoringSharedMemory(resourcesToCheck, 100, 1);
+
+ assertThat(couldHold, is(false));
+ }
+
+ @Test
+ public void testCouldHoldWithEnoughResources() {
+ Map<String, Double> allResources = new HashMap<>();
+ allResources.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ allResources.put(gpuResourceName, 2.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResources));
+ NormalizedResources resourcesToCheck = new NormalizedResources(normalize(allResources));
+
+ boolean couldHold = resources.couldHoldIgnoringSharedMemory(resourcesToCheck, 100, 100);
+
+ assertThat(couldHold, is(true));
+ }
+
+ @Test
+ public void testCalculateAvgUsageWithNoResourcesInTotal() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.emptyMap()));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.emptyMap()));
+
+ double avg = resources.calculateAveragePercentageUsedBy(usedResources, 0, 0);
+
+ assertThat(avg, is(100.0));
+ }
+
+ @Test
+ public void testCalculateAvgWithOnlyCpu() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ double avg = resources.calculateAveragePercentageUsedBy(usedResources, 0, 0);
+
+ assertThat(avg, is(50.0));
+ }
+
+ @Test
+ public void testCalculateAvgWithCpuAndMem() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ double avg = resources.calculateAveragePercentageUsedBy(usedResources, 4, 1);
+
+ assertThat(avg, is((50.0 + 25.0)/2));
+ }
+
+ @Test
+ public void testCalculateAvgWithCpuMemAndGenericResource() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ allResourcesMap.put(gpuResourceName, 10.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ usedResourcesMap.put(gpuResourceName, 1.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ double avg = resources.calculateAveragePercentageUsedBy(usedResources, 4, 1);
+
+ assertThat(avg, is((50.0 + 25.0 + 10.0)/3));
+ }
+
+ @Test
+ public void testCalculateAvgWithUnusedResource() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ allResourcesMap.put(gpuResourceName, 10.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ double avg = resources.calculateAveragePercentageUsedBy(usedResources, 4, 1);
+
+ //The resource that is not used should count as if it is being used 0%
+ assertThat(avg, is((50.0 + 25.0)/3));
+ }
+
+ @Test
+ public void testCalculateAvgThrowsIfTotalIsMissingCpu() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 5)));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateAveragePercentageUsedBy(usedResources, 0, 0);
+ }
+
+ @Test
+ public void testCalculateAvgThrowsIfTotalIsMissingMemory() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateAveragePercentageUsedBy(usedResources, 100, 500);
+ }
+
+ @Test
+ public void testCalculateAvgWithResourceMissingFromTotal() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ usedResourcesMap.put(gpuResourceName, 1.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateAveragePercentageUsedBy(usedResources, 4, 1);
+ }
+
+ @Test
+ public void testCalculateAvgWithTooLittleResourceInTotal() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ allResourcesMap.put(gpuResourceName, 1.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ usedResourcesMap.put(gpuResourceName, 5.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateAveragePercentageUsedBy(usedResources, 4, 1);
+ }
+
+ @Test
+ public void testCalculateMinUsageWithNoResourcesInTotal() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.emptyMap()));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.emptyMap()));
+
+ double min = resources.calculateMinPercentageUsedBy(usedResources, 0, 0);
+
+ assertThat(min, is(100.0));
+ }
+
+ @Test
+ public void testCalculateMinWithOnlyCpu() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ double min = resources.calculateMinPercentageUsedBy(usedResources, 0, 0);
+
+ assertThat(min, is(50.0));
+ }
+
+ @Test
+ public void testCalculateMinWithCpuAndMem() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ double min = resources.calculateMinPercentageUsedBy(usedResources, 4, 1);
+
+ assertThat(min, is(25.0));
+ }
+
+ @Test
+ public void testCalculateMinWithCpuMemAndGenericResource() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ allResourcesMap.put(gpuResourceName, 10.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ usedResourcesMap.put(gpuResourceName, 1.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ double min = resources.calculateMinPercentageUsedBy(usedResources, 4, 1);
+
+ assertThat(min, is(10.0));
+ }
+
+ @Test
+ public void testCalculateMinWithUnusedResource() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ allResourcesMap.put(gpuResourceName, 10.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ double min = resources.calculateMinPercentageUsedBy(usedResources, 4, 1);
+
+ //The resource that is not used should count as if it is being used 0%
+ assertThat(min, is(0.0));
+ }
+
+ @Test
+ public void testCalculateMinThrowsIfTotalIsMissingCpu() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 5)));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateMinPercentageUsedBy(usedResources, 0, 0);
+ }
+
+ @Test
+ public void testCalculateMinThrowsIfTotalIsMissingMemory() {
+ NormalizedResources resources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 2)));
+ NormalizedResources usedResources = new NormalizedResources(normalize(Collections.singletonMap(Constants.COMMON_CPU_RESOURCE_NAME, 1)));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateMinPercentageUsedBy(usedResources, 100, 500);
+ }
+
+ @Test
+ public void testCalculateMinWithResourceMissingFromTotal() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ usedResourcesMap.put(gpuResourceName, 1.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateMinPercentageUsedBy(usedResources, 4, 1);
+ }
+
+ @Test
+ public void testCalculateMinWithTooLittleResourceInTotal() {
+ Map<String, Double> allResourcesMap = new HashMap<>();
+ allResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 2.0);
+ allResourcesMap.put(gpuResourceName, 1.0);
+ NormalizedResources resources = new NormalizedResources(normalize(allResourcesMap));
+ Map<String, Double> usedResourcesMap = new HashMap<>();
+ usedResourcesMap.put(Constants.COMMON_CPU_RESOURCE_NAME, 1.0);
+ usedResourcesMap.put(gpuResourceName, 5.0);
+ NormalizedResources usedResources = new NormalizedResources(normalize(usedResourcesMap));
+
+ expectedException.expect(IllegalArgumentException.class);
+ resources.calculateMinPercentageUsedBy(usedResources, 4, 1);
+ }
+}
http://git-wip-us.apache.org/repos/asf/storm/blob/41db23fe/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/ResourceMapArrayBridgeTest.java
----------------------------------------------------------------------
diff --git a/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/ResourceMapArrayBridgeTest.java b/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/ResourceMapArrayBridgeTest.java
new file mode 100644
index 0000000..f6dedb3
--- /dev/null
+++ b/storm-server/src/test/java/org/apache/storm/scheduler/resource/normalization/ResourceMapArrayBridgeTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2018 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.storm.scheduler.resource.normalization;
+
+import org.apache.storm.scheduler.resource.ResourceMapArrayBridge;
+import org.apache.storm.scheduler.resource.NormalizedResources;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+
+public class ResourceMapArrayBridgeTest {
+
+ private final String gpuResourceName = "gpu";
+ private final String disksResourceName = "disks";
+
+ private Map<String, Double> normalize(Map<String, ? extends Number> resources) {
+ return NormalizedResources.RESOURCE_NAME_NORMALIZER.normalizedResourceMap(resources);
+ }
+
+ @Test
+ public void testCanTranslateBackAndForthBetweenMapAndArrayConsistently() {
+ ResourceMapArrayBridge bridge = new ResourceMapArrayBridge();
+
+ Map<String, Double> allResources = new HashMap<>();
+ allResources.put(gpuResourceName, 2.0);
+ allResources.put(disksResourceName, 64.0);
+ Map<String, Double> normalizedResources = normalize(allResources);
+ double[] resources = bridge.translateToResourceArray(normalizedResources);
+
+ Map<String, Integer> resourceNamesToArrayIndex = bridge.getResourceNamesToArrayIndex();
+ assertThat(resourceNamesToArrayIndex.size(), is(2));
+ int gpuIndex = resourceNamesToArrayIndex.get(gpuResourceName);
+ int disksIndex = resourceNamesToArrayIndex.get(disksResourceName);
+
+ assertThat(resources.length, is(2));
+ assertThat(resources[gpuIndex], is(2.0));
+ assertThat(resources[disksIndex], is(64.0));
+
+ Map<String, Double> roundTrippedResources = bridge.translateFromResourceArray(resources);
+ assertThat(roundTrippedResources, is(normalizedResources));
+
+ double[] roundTrippedResourceArray = bridge.translateToResourceArray(roundTrippedResources);
+ assertThat(roundTrippedResourceArray, equalTo(resources));
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/storm/blob/41db23fe/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/NormalizedResourcesRule.java
----------------------------------------------------------------------
diff --git a/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/NormalizedResourcesRule.java b/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/NormalizedResourcesRule.java
deleted file mode 100644
index 26bc14d..0000000
--- a/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/NormalizedResourcesRule.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.storm.scheduler.resource.strategies.scheduling;
-
-import org.apache.storm.scheduler.resource.NormalizedResources;
-import org.junit.rules.TestRule;
-import org.junit.runner.Description;
-import org.junit.runners.model.Statement;
-
-public class NormalizedResourcesRule implements TestRule {
-
- public static class NRStatement extends Statement {
- private final Statement base;
-
- public NRStatement(Statement base) {
- this.base = base;
- }
-
- @Override
- public void evaluate() throws Throwable {
- NormalizedResources.resetResourceNames();
- try {
- base.evaluate();
- } finally {
- NormalizedResources.resetResourceNames();
- }
- }
- }
-
- @Override
- public Statement apply(Statement statement, Description description) {
- return new NRStatement(statement);
- }
-}
http://git-wip-us.apache.org/repos/asf/storm/blob/41db23fe/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/TestDefaultResourceAwareStrategy.java
----------------------------------------------------------------------
diff --git a/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/TestDefaultResourceAwareStrategy.java b/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/TestDefaultResourceAwareStrategy.java
index 6a3fcbb..f82d0f7 100644
--- a/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/TestDefaultResourceAwareStrategy.java
+++ b/storm-server/src/test/java/org/apache/storm/scheduler/resource/strategies/scheduling/TestDefaultResourceAwareStrategy.java
@@ -18,6 +18,7 @@
package org.apache.storm.scheduler.resource.strategies.scheduling;
+import org.apache.storm.scheduler.resource.normalization.NormalizedResourcesRule;
import java.util.Collections;
import org.apache.storm.Config;
import org.apache.storm.generated.StormTopology;