diff --git a/tools/test/scenarios/net-prerequisites.xml b/tools/test/scenarios/net-prerequisites.xml
new file mode 100644
index 0000000..33f836a
--- /dev/null
+++ b/tools/test/scenarios/net-prerequisites.xml
@@ -0,0 +1,22 @@
+<!--
+  ~ Copyright 2016 Open Networking Laboratory
+  ~
+  ~ 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.
+  -->
+<scenario name="net-prerequisites" description="Network setup prerequisites check">
+    <group name="Net-Prerequisites">
+        <step name="Check-mininet" exec="ssh ${ONOS_USER}@${OCN} type mn"/>
+        <step name="Check-screen" exec="ssh ${ONOS_USER}@${OCN} type screen"/>
+        <step name="Check-arping" exec="ssh ${ONOS_USER}@${OCN} type arping"/>
+    </group>
+</scenario>
