staf4ruby 0.1.0

data/test/test.rb

@@ -0,0 +1,662 @@
+#! /usr/bin/env ruby
+##############################################################################
+# Copyright (c) 2013 Spectra Logic corp
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+##############################################################################
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'rbconfig'
+require 'test/unit'
+
+require 'staf4ruby'
+
+module Staf
+
+  class TestHandleRegister < Test::Unit::TestCase
+    def setup
+      @handle = nil
+    end
+
+    def teardown
+      if @handle
+        @handle.unregister
+      end
+    end
+
+    def test_ConstructWithStandardHandle_neg1
+      # Should get an error when passing an integer as a Standard handle
+      assert_raises(TypeError) do
+        @handle = STAFHandle.new(1)
+      end
+    end
+
+    def test_ConstructWithStaticHandle_neg1
+      # Should get an error when passing a string as a static handle
+      assert_raises(TypeError) do
+        @handle = STAFHandle.new("MyHandle", STAFHandle::Static)
+      end
+    end
+
+    def test_ConstructWithStandardHandle_pos1
+      assert_nothing_raised() do
+        @handle = STAFHandle.new("test_ConstructWithStandardHandle_pos1")
+        assert @handle.is_a? STAFHandle
+      end
+    end
+  end
+
+  class TestSubmitWithStandardHandle < Test::Unit::TestCase
+    def setup
+      @handle = STAFHandle.new("TestSubmitWithStandardHandle")
+    end
+
+    def teardown
+      if @handle
+        @handle.unregister
+      end
+    end
+
+    def test_doUnmarshallingResultDefault
+      assert @handle.doUnmarshallResult 
+    end
+
+    def test_ping
+      result = @handle.submit("local", "ping", "ping")
+      assert_equal(STAFResult::Ok, result.rc)
+      assert_equal("PONG", result.result)
+    end
+
+    def test_var_resolve_string
+      result = @handle.submit("local", "var", "resolve string {STAF/Config/MachineNickname}")
+      assert_equal(STAFResult::Ok, result.rc)
+    end
+
+    def test_os_name
+      result = @handle.submit("local", "var", "resolve string {STAF/Config/OS/Name}")
+      assert_equal(STAFResult::Ok, result.rc)
+      known_os_names = ["FreeBSD", "Linux"]
+      assert known_os_names.include?(result.result)
+    end
+  end
+
+  class TestSubmitWithStaticHandle < Test::Unit::TestCase
+    def setup
+      @standard_handle = STAFHandle.new("TestSubmitWithStaticHandle1")
+      result = @standard_handle.submit("local", "HANDLE", "CREATE HANDLE NAME TestSubmitWithStaticHandle2");
+      assert_equal(STAFResult::Ok, result.rc)
+      @static_handle_number = result.result.to_i
+      assert @static_handle_number.is_a? Integer
+      @static_handle = STAFHandle.new(@static_handle_number, STAFHandle::Static)
+      assert_equal(STAFHandle::Static, @static_handle.handleType)
+    end
+
+    def teardown
+      if @static_handle
+        result = @static_handle.submit("local", "HANDLE", "DELETE HANDLE #{@static_handle_number}")
+        assert_equal STAFResult::Ok, result.rc
+        rc = @static_handle.unregister
+        assert_equal(STAFResult::Ok, rc)
+        @static_handle = nil
+      end
+      if @standard_handle
+        rc = @standard_handle.unregister
+        assert_equal(STAFResult::Ok, rc)
+        @standard_handle = nil
+      end
+    end
+
+    def test_ping
+      result = @static_handle.submit("local", "ping", "ping")
+      assert_equal(STAFResult::Ok, result.rc)
+      assert_equal("PONG", result.result)
+    end
+
+    def test_doUnmarshallingResultDefault
+      assert @static_handle.doUnmarshallResult 
+    end
+
+    def test_query_after_delete
+      # Delete the static handle, then verify that requests that attempt to use
+      # it fail.  We must then unregister the static_handle so the teardown
+      # method does not raise an exception.
+      result = @static_handle.submit("local", "HANDLE", "DELETE HANDLE #{@static_handle_number}")
+      assert_equal STAFResult::Ok, result.rc
+      result = @static_handle.submit("local", "HANDLE", "QUERY HANDLE #{@static_handle_number}")
+      assert_equal STAFResult::HandleDoesNotExist, result.rc
+      @static_handle.unregister
+      @static_handle = nil
+    end
+  end
+
+  class TestDoUnmarshallResult < Test::Unit::TestCase
+    def setup
+      @handle = STAFHandle.new("TestSubmitWithStandardHandle")
+    end
+
+    def teardown
+      if @handle
+        @handle.unregister
+      end
+    end
+
+    def do_false
+      assert_equal @handle.doUnmarshallResult, false
+      result = @handle.submit("local", "MISC", "WHOAMI")
+      assert_equal STAFResult::Ok, result.rc
+      assert_equal nil, result.resultContext
+      assert_equal nil, result.resultObj
+    end
+
+    def do_true
+      assert_equal @handle.doUnmarshallResult, true
+      result = @handle.submit("local", "MISC", "WHOAMI")
+      assert_equal STAFResult::Ok, result.rc
+      assert_equal result.resultContext.rootObject, Staf::unmarshall(result.result).rootObject
+      assert_equal result.resultObj, Staf::unmarshall(result.result).rootObject()
+    end
+
+    def test_blank
+      @handle.setDoUnmarshallResult ""
+      do_false
+    end
+
+    def test_default
+      do_true
+    end
+
+    def test_one
+      @handle.setDoUnmarshallResult 1
+      do_true
+    end
+
+    def test_true
+      @handle.setDoUnmarshallResult true
+      do_true
+    end
+
+    def test_zero
+      @handle.setDoUnmarshallResult 0
+      do_false
+    end
+  end
+
+  
+  class TestLogService < Test::Unit::TestCase
+    #TODO: implement the STAFLog class for the bindings to be complete
+    #SpectraLogic doesn't need it, though.
+  end
+
+  class TestMarshall < Test::Unit::TestCase
+    # Test the marshall function
+    def test_array
+      expected = "@SDT/[3:33:@SDT/$S:1:1@SDT/$S:1:2@SDT/$S:1:3"
+      assert_equal expected, Staf.marshall([1,2,3])
+    end
+
+    def test_hash1
+      assert_equal "@SDT/{:15::1:1@SDT/$S:1:2", Staf::marshall({1 => 2})
+    end
+
+    def test_hash2
+      data = {1 => 3, 33 => 789}
+      expected = "@SDT/{:33::1:1@SDT/$S:1:3:2:33@SDT/$S:3:789"
+      assert_equal expected, Staf::marshall(data)
+    end
+
+    def test_int
+      assert_equal "@SDT/$S:1:1", Staf::marshall(1)
+    end
+
+    def test_nil
+      assert_equal '@SDT/$0:0:', Staf::marshall(nil)
+    end
+
+    def test_string
+      assert_equal "@SDT/$S:3:abc", Staf::marshall("abc")
+    end
+
+    def test_composite
+      # Note, this test relies on the ordered-hash feature of ruby 1.9 and
+      # later.  It may fail on older versions of ruby.
+      myTestMap = {
+                    'outputs' => ['TestA.out', 'TestA.err'],
+                    'testType' => 'FVT',
+                    'name' => 'TestA', 'exec' => '/tests/TestA.py',
+                   }
+      marshalledResult = Staf::marshall(myTestMap)
+      expectedResult = (
+        "@SDT/{:138::7:outputs@SDT/[2:38:@SDT/$S:9:TestA.out" +
+        "@SDT/$S:9:TestA.err:8:testType@SDT/$S:3:FVT:4:name" +
+        "@SDT/$S:5:TestA:4:exec@SDT/$S:15:/tests/TestA.py")
+      assert_equal expectedResult, marshalledResult
+    end
+  end
+
+  class TestUnMarshall < Test::Unit::TestCase
+    def test_array
+      data = "@SDT/[3:33:@SDT/$S:1:1@SDT/$S:1:2@SDT/$S:1:3"
+      expected = ["1","2","3"]
+      assert_equal expected, Staf.unmarshall(data).rootObject
+    end
+
+    def test_hash1
+      data = "@SDT/{:15::1:1@SDT/$S:1:2"
+      expected = {"1" => "2"}
+      assert_equal expected, Staf.unmarshall(data).rootObject
+    end
+
+    def test_hash2
+      expected = {"1" => "3", "33" => "789"}
+      data = "@SDT/{:33::1:1@SDT/$S:1:3:2:33@SDT/$S:3:789"
+      assert_equal expected, Staf.unmarshall(data).rootObject
+    end
+
+    def test_int
+      assert_equal 1.to_s, Staf::unmarshall("@SDT/$S:1:1").rootObject
+    end
+
+    def test_nil
+      assert_equal nil.to_s, Staf::unmarshall('@SDT/$0:0:').rootObject
+    end
+
+    def test_string
+      data = "@SDT/$S:3:abc"
+      expected = "abc"
+      assert_equal expected, Staf::unmarshall(data).rootObject
+    end
+
+    def test_composite
+      # Note, this test relies on the ordered-hash feature of ruby 1.9 and
+      # later.  It may fail on older versions of ruby.
+      expected = {
+                    'outputs' => ['TestA.out', 'TestA.err'],
+                    'testType' => 'FVT',
+                    'name' => 'TestA', 'exec' => '/tests/TestA.py',
+                   }
+      data = (
+        "@SDT/{:138::7:outputs@SDT/[2:38:@SDT/$S:9:TestA.out" +
+        "@SDT/$S:9:TestA.err:8:testType@SDT/$S:3:FVT:4:name" +
+        "@SDT/$S:5:TestA:4:exec@SDT/$S:15:/tests/TestA.py")
+      assert_equal expected, Staf::unmarshall(data).rootObject
+    end
+
+    def test_context
+      myMapClassDef = STAFMapClassDefinition.new('Test/MyMap')
+      myMapClassDef.addKey('name', 'Name')
+      myMapClassDef.addKey('exec', 'Executable')
+
+      testList = [
+                   {'name' => 'TestA', 'exec' => '/tests/TestA.py'},
+                   {'name' => 'TestB', 'exec' => '/tests/TestB.sh'},
+                   {'name' => 'TestC', 'exec' => '/tests/TestC.cmd'}
+                 ]
+
+      mc = STAFMarshallingContext.new()
+      mc.setMapClassDefinition(myMapClassDef)
+
+      myTestList = []
+
+      for test in testList
+          testMap = myMapClassDef.createInstance()
+          testMap['name'] = test['name']
+          testMap['exec'] = test['exec']
+          myTestList << testMap
+      end
+
+      mc.rootObject = myTestList
+      message = Staf::marshall(mc)
+      mc2 = Staf::unmarshall(message)
+      mc2.rootObject
+
+      assert_equal mc.mapClassMap, mc2.mapClassMap
+      assert_equal mc.rootObject, mc2.rootObject
+    end
+
+    # Test unmarshalling the output of
+    # "staf local process start command whoami wait returnresult returnstderr"
+    def test_process_whoami
+      data = "@SDT/*:826:@SDT/{:587::13:map-class-map@SDT/{:559::35:STAF/Service/Process/CompletionInfo@SDT/{:261::4:keys@SDT/[3:189:@SDT/{:56::12:display-name@SDT/$S:11:Return Code:3:key@SDT/$S:2:rc@SDT/{:48::12:display-name@SDT/$S:3:Key:3:key@SDT/$S:3:key@SDT/{:55::12:display-name@SDT/$S:5:Files:3:key@SDT/$S:8:fileList:4:name@SDT/$S:35:STAF/Service/Process/CompletionInfo:35:STAF/Service/Process/ReturnFileInfo@SDT/{:198::4:keys@SDT/[2:126:@SDT/{:56::12:display-name@SDT/$S:11:Return Code:3:key@SDT/$S:2:rc@SDT/{:50::12:display-name@SDT/$S:4:Data:3:key@SDT/$S:4:data:4:name@SDT/$S:35:STAF/Service/Process/ReturnFileInfo@SDT/%:217::35:STAF/Service/Process/CompletionInfo@SDT/$S:1:0@SDT/$0:0:@SDT/[2:145:@SDT/%:65::35:STAF/Service/Process/ReturnFileInfo@SDT/$S:1:0@SDT/$S:5:root\n@SDT/%:60::35:STAF/Service/Process/ReturnFileInfo@SDT/$S:1:0@SDT/$S:0:"
+      assert_equal "root\n", Staf::unmarshall(data).rootObject["fileList"][0]["data"]
+    end
+  end
+
+  class TestUnMarshallQuery < Test::Unit::TestCase
+    def setup
+      @handle = STAFHandle.new("TestSubmitWithStandardHandle")
+      @myTestMap = {'name' => 'TestA', 'exec' => '/tests/TestA.py',
+                    'testType' => 'FVT',
+                    'outputs' => ['TestA.out', 'TestA.err']}
+    end
+
+    def teardown
+      if @handle
+        @handle.unregister
+      end
+    end
+
+    def test_fs_query
+      filename = "{STAF/Config/ConfigFile}"
+      result = @handle.submit("local", "FS", "query entry #{filename}")
+      assert_equal STAFResult::Ok, result.rc
+      mc = Staf::unmarshall(result.result)
+      entryMap = mc.rootObject
+      assert_equal "F", entryMap['type']
+      assert (entryMap["lowerSize"].to_i > 0)
+      assert entryMap.has_key?('lastModifiedTimestamp')
+    end
+
+    # TODO: add a test for the IGNORE_INDIRECT_OBJECTS thing from TestPython.py
+    # at around lines 790 - 841.  I didn't add it because I can't understand
+    # what the test is doing
+
+    def test_invalid_queue
+      # Create some invalid marshalling data and queue it;  Get it off the
+      # queue (auto-unmarshalling will be done) and verify results in the
+      # invalid marshalling data string in the message
+      message = (
+        "@SDT/{:177::2:RC@SDT/$S:1:0:6:IPInfo@SDT/$S:36:" +
+        "9.42.126.76|255.255.252.0|9.42.124.1:3:Msg@SDT/$S:46:Static IP " +
+        "arguments are processed " +
+        "successfully:9:Timestamp@SDT/$S:19:2009-01-16 14:41:45" +
+        "Connecting to: http://9.42.106.28:8080")
+      result = @handle.submit('local', 'queue', "queue message #{message}")
+      assert_equal STAFResult::Ok, result.rc
+      result = @handle.submit("local", "queue", "get wait 5000")
+      assert_equal STAFResult::Ok, result.rc
+      messageMap = result.resultObj
+      assert_equal message, messageMap['message']
+    end
+
+    def test_valid_queue
+      #XXX: this test uses the public STAF queue.  Other running processes could
+      #interfere with this test.  It really ought to be using a private STAF
+      #instance name
+      msg = Staf::marshall(@myTestMap)
+      result = @handle.submit("local", "queue", "queue message #{msg}")
+      assert_equal STAFResult::Ok, result.rc
+      result = @handle.submit("local", "queue", "get wait 5000")
+      assert_equal STAFResult::Ok, result.rc
+      mc = Staf::unmarshall(result.result)
+      yourTestMap = mc.rootObject["message"]
+      assert_equal @myTestMap, yourTestMap
+    end
+  end
+
+  module MapClassHelper
+    def mapClassHelperSetup
+      @mapClassDefName = "Test/MyMap"
+      @mapClassDef = STAFMapClassDefinition.new(@mapClassDefName)
+      @mapClassDef.addKey("name", "Name")
+      @mapClassDef.addKey("exec", "Executable")
+      @mapClassDef.addKey("testType", "Test Type")
+      @mapClassDef.setKeyProperty("testType", "display-short-name", "test")
+      @mapClassDef.addKey("outputs", "Outputs")
+      @expectedKeyMap = [
+        {'display-name' => 'Name', 'key' => 'name'},
+        {'display-name' => 'Executable', 'key' => 'exec'},
+        {'display-name' => 'Test Type', 'key' => 'testType',
+         'display-short-name' => 'test'},
+        {'display-name' => 'Outputs', 'key' => 'outputs'}
+      ] 
+    end
+  end
+
+  class TestMapClass < Test::Unit::TestCase
+    include MapClassHelper
+    def setup
+      mapClassHelperSetup
+    end
+
+    def test_keys
+      assert_equal @expectedKeyMap, @mapClassDef.keys
+    end
+
+    def test_mapClass
+      expectedMapClass = {
+        'keys' => @expectedKeyMap,
+        'name' => @mapClassDefName
+      }
+      assert_equal expectedMapClass, @mapClassDef.mapClassDef
+    end
+
+    def test_mapClassDefName
+      assert_equal @mapClassDefName, @mapClassDef.name
+    end
+  end
+
+  class TestStafMarshallingContext < Test::Unit::TestCase
+    include MapClassHelper
+    def setup
+      mapClassHelperSetup
+      @mc = STAFMarshallingContext.new
+      @mc.setMapClassDefinition(@mapClassDef)
+    end
+
+    def test_hasMapClassDefinition
+      assert @mc.hasMapClassDefinition('Test/MyMap')
+    end
+
+    def test_keys
+      assert_equal @expectedKeyMap, @mc.getMapClassDefinition('Test/MyMap').keys
+    end
+
+    def test_mapClass
+      expectedMapClass = {
+        'keys' => @expectedKeyMap,
+        'name' => @mapClassDefName
+      }
+      assert_equal expectedMapClass, @mc.getMapClassDefinition('Test/MyMap').mapClassDef
+    end
+
+    def test_mapClassDefinitionIterator
+      assert_equal ['Test/MyMap'], @mc.mapClassDefinitionIterator
+    end
+  end
+
+  class TestStafMarshallingContextRootObject < Test::Unit::TestCase
+    include MapClassHelper
+    def setup
+      mapClassHelperSetup
+      @mc = STAFMarshallingContext.new
+      @mc.setMapClassDefinition(@mapClassDef)
+      @myTestMap = {
+                    'name'=> 'TestA',
+                    'outputs'=> ['TestA.out', 'TestA.err'],
+                    'exec'=> '/tests/TestA.py',
+                    'testType'=> 'FVT',
+                    }
+      @marshalledResult = Staf::marshall(@myTestMap)
+      @mc.rootObject = @myTestMap
+    end
+
+    def test_isMarshalledData_neg
+      assert (not Staf::isMarshalledData('xyz'))
+      assert (not @mc.isMarshalledData('xyz'))
+    end
+
+    def test_isMarshalledData_pos
+      assert @mc.isMarshalledData(@marshalledResult)
+    end
+
+    def test_marshall
+      expectedResult = (
+        "@SDT/*:558:" + 
+          "@SDT/{:398:" + 
+            ":13:map-class-map" + 
+              "@SDT/{:370:" + 
+                ":10:Test/MyMap" +
+                  "@SDT/{:345:" +
+                    ":4:name" +
+                      "@SDT/$S:10:Test/MyMap" +
+                    ":4:keys" +
+                      "@SDT/[4:298:" +
+                        "@SDT/{:50:" +
+                          ":3:key" +
+                            "@SDT/$S:4:name" +
+                          ":12:display-name" +
+                            "@SDT/$S:4:Name" +
+                        "@SDT/{:57:" + 
+                          ":3:key" + 
+                            "@SDT/$S:4:exec" + 
+                          ":12:display-name" +
+                            "@SDT/$S:10:Executable" +
+                        "@SDT/{:95:" +
+                          ":3:key" + 
+                            "@SDT/$S:8:testType" +
+                          ":12:display-name" +
+                            "@SDT/$S:9:Test Type" +
+                          ":18:display-short-name" +
+                            "@SDT/$S:4:test" +
+                        "@SDT/{:56:" +
+                          ":3:key" +
+                            "@SDT/$S:7:outputs" +
+                          ":12:display-name" + 
+                            "@SDT/$S:7:Outputs" +
+          "@SDT/{:138:" +
+            ":4:name" + 
+              "@SDT/$S:5:TestA" +
+            ":7:outputs" +
+              "@SDT/[2:38:" +
+                "@SDT/$S:9:TestA.out" +
+                "@SDT/$S:9:TestA.err" +
+            ":4:exec" +
+              "@SDT/$S:15:/tests/TestA.py" +
+            ":8:testType" +
+              "@SDT/$S:3:FVT")
+      assert_equal expectedResult, Staf::marshall(@mc, @mc)
+      assert_equal expectedResult, @mc.marshall
+    end
+
+    def test_primaryObject
+      assert_equal @mc, @mc.getPrimaryObject
+    end
+
+    def test_rootObj
+      assert_equal @myTestMap, @mc.rootObject
+    end
+
+    def test_unmarshall
+      assert_equal @myTestMap, Staf::unmarshall(@mc.marshall).rootObject
+    end
+
+    # TODO: add tests for mc.to_s and mc.inspect
+  end
+
+  class TestStafMarshallingContextClone < Test::Unit::TestCase
+    include MapClassHelper
+    def setup
+      mapClassHelperSetup
+      @mc = STAFMarshallingContext.new
+      @mc.setMapClassDefinition(@mapClassDef)
+      @myTestMap = {
+                    'name'=> 'TestA',
+                    'outputs'=> ['TestA.out', 'TestA.err'],
+                    'exec'=> '/tests/TestA.py',
+                    'testType'=> 'FVT',
+                    }
+      @marshalledResult = Staf::marshall(@myTestMap)
+      @mc.rootObject = @myTestMap
+      @mc2 = STAFMarshallingContext.new(@myTestMap, @mc.mapClassMap)
+    end
+    
+    def test_hasMapClassDefinition
+      assert @mc2.hasMapClassDefinition('Test/MyMap')
+    end
+    
+    def test_rootObj
+      assert_equal @myTestMap, @mc2.rootObject
+    end
+  end
+
+
+  class TestMonitor < Test::Unit::TestCase
+    #TODO: implement the STAFMonitor class for the bindings to be complete
+    #SpectraLogic doesn't need it, though.
+  end
+
+
+  class TestPrivateData < Test::Unit::TestCase
+    def all_privacy_removed(data)
+      escapedData = Staf::escapePrivacyDelimiters(data)[1]
+      dataWithPrivacy = Staf::addPrivacyDelimiters(escapedData)[1]
+      dataWithAllPrivacyRemoved =
+        Staf::removePrivacyDelimiters(dataWithPrivacy, 0)[1]
+      assert_equal data, dataWithAllPrivacyRemoved
+    end
+
+    def privacy_removed(data)
+      escapedData = Staf::escapePrivacyDelimiters(data)[1]
+      dataWithPrivacy = Staf::addPrivacyDelimiters(escapedData)[1]
+      dataWithPrivacyRemoved =
+        Staf::removePrivacyDelimiters(dataWithPrivacy, 1)[1]
+      assert_equal data, dataWithPrivacyRemoved
+    end
+
+    def do_test(data)
+#       privacy_removed(data)
+      all_privacy_removed(data)
+    end
+
+    def test_secret
+      do_test("secret")
+    end
+
+    def test_privatesecret
+      do_test("!!@secret@!!")
+    end
+
+    def test_pw
+      do_test('Pw: !!@pw@!!')
+    end
+
+    def test_escaped_secret
+      do_test('^!!@secret@!!')
+    end
+
+    def test_escaped_secret2
+      do_test('^!!@secret^@!!')
+    end
+    
+    def test_halfprivate_secret
+      do_test('!!@secret')
+    end
+    
+    def test_halfprivate_secret2
+      do_test('!!@secret^@!!')
+    end
+
+    def test_pw2
+      do_test('Pw1=%s, Pw2=%s.' % [Staf::addPrivacyDelimiters('a')[1],
+                                   Staf::addPrivacyDelimiters('pw')[1]])
+    end
+
+    def test_caret_ab
+      do_test('^%s^%s' % [Staf::addPrivacyDelimiters('a')[1],
+                          Staf::addPrivacyDelimiters('b')[1]])
+    end
+
+    def test_poorly_nested
+      do_test('Pw1=!!@secret, !!@pw@!!.')
+    end
+    
+    def test_poorly_nested2
+      do_test('Pw1=!!@secret@!!, !!@pw.')
+    end
+
+    def test_nested
+      do_test('Msg: !!@Pw: ^!!@pw^@!!@!!')
+    end
+    
+    def test_nested2
+      do_test('@!!a!!@b@!!')
+    end
+    
+    def test_empty
+      do_test ''
+    end
+    
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+##############################################################################
+# Copyright (c) 2013 Spectra Logic corp
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+##############################################################################
+
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start
+end