nasl 0.0.8 → 0.1.1

data/test/unit/parser/test_assignment.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -56,7 +56,14 @@ class TestAssignment < Test::Unit::TestCase
   def test_function
     same(
       "q = foo();",
-      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><call><identifier name="foo"/></call></assignment></tree>'
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><call><lvalue><identifier name="foo"/></lvalue></call></assignment></tree>'
+    )
+  end
+
+  def test_reference
+    same(
+      "q = @foo;",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><reference><identifier name="foo"/></reference></assignment></tree>'
     )
   end
 
@@ -101,11 +108,75 @@ class TestAssignment < Test::Unit::TestCase
   def test_conditional
     same(
       "if (q = foo());",
-      '<tree><if><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><call><identifier name="foo"/></call></assignment><empty/></if></tree>'
+      '<tree><if><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><call><lvalue><identifier name="foo"/></lvalue></call></assignment><empty/></if></tree>'
     )
     same(
       "while (q = foo());",
-      '<tree><while><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><call><identifier name="foo"/></call></assignment><empty/></while></tree>'
+      '<tree><while><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><call><lvalue><identifier name="foo"/></lvalue></call></assignment><empty/></while></tree>'
+    )
+  end
+
+  def test_list
+    same(
+      "q = [];",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><list></list></assignment></tree>'
+    )
+
+    same(
+      "q = [[[]], [[]], [[]]];",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><list><list><list></list></list><list><list></list></list><list><list></list></list></list></assignment></tree>'
+    )
+
+    same(
+      "q = [1];",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><list><integer value="1"/></list></assignment></tree>'
+    )
+
+    same(
+      "q = [1, 'b', foo()];",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><list><integer value="1"/><data>b</data><call><lvalue><identifier name="foo"/></lvalue></call></list></assignment></tree>'
+    )
+
+    same(
+      "foo(arg:[1]);",
+      '<tree><call><lvalue><identifier name="foo"/></lvalue><argument type="named"><identifier name="arg"/><list><integer value="1"/></list></argument></call></tree>'
+    )
+
+    same(
+      "q = [] + [];",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><expression><op>+</op><list></list><list></list></expression></assignment></tree>'
+    )
+  end
+
+  def test_array
+    same(
+      "q = {};",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><array></array></assignment></tree>'
+    )
+
+    same(
+      "q = {'a':{'b':{}}, 'c':{'d':{}}, 'e':{'f':{}}};",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><array><key_value_pair><data>a</data><array><key_value_pair><data>b</data><array></array></key_value_pair></array></key_value_pair><key_value_pair><data>c</data><array><key_value_pair><data>d</data><array></array></key_value_pair></array></key_value_pair><key_value_pair><data>e</data><array><key_value_pair><data>f</data><array></array></key_value_pair></array></key_value_pair></array></assignment></tree>'
+    )
+
+    same(
+      'q = {"a":1};',
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><array><key_value_pair><string>a</string><integer value="1"/></key_value_pair></array></assignment></tree>'
+    )
+
+    same(
+      "q = {1:1, 2:'b', 3:foo()};",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><array><key_value_pair><integer value="1"/><integer value="1"/></key_value_pair><key_value_pair><integer value="2"/><data>b</data></key_value_pair><key_value_pair><integer value="3"/><call><lvalue><identifier name="foo"/></lvalue></call></key_value_pair></array></assignment></tree>'
+    )
+
+    same(
+      "foo(arg:{1:1});",
+      '<tree><call><lvalue><identifier name="foo"/></lvalue><argument type="named"><identifier name="arg"/><array><key_value_pair><integer value="1"/><integer value="1"/></key_value_pair></array></argument></call></tree>'
+    )
+
+    same(
+      "q = {} + {};",
+      '<tree><assignment><op>=</op><lvalue><identifier name="q"/></lvalue><expression><op>+</op><array></array><array></array></expression></assignment></tree>'
     )
   end
 end

data/test/unit/parser/test_blank.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without

data/test/unit/parser/test_block.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -27,6 +27,34 @@
 class TestBlock < Test::Unit::TestCase
   include Nasl::Test
 
+  def test_each
+    tree = parse(
+      <<-EOF
+      {
+        a = 1;
+        break;
+        fn();
+        ;
+      }
+      EOF
+    )
+    assert_not_nil(tree)
+
+    blks = tree.all(:Block)
+    assert_not_nil(blks)
+    assert_equal(1, blks.length)
+
+    clss = [:Assignment, :Break, :Call, :Empty]
+
+    i = 0
+    blks.first.each do |stmt|
+      assert_not_nil(stmt)
+      assert_equal(Nasl.const_get(clss[i]), stmt.class)
+
+      i += 1
+    end
+  end
+
   def test_empty
     same("{}", "<tree><block></block></tree>")
     same("{;}", "<tree><block><empty/></block></tree>")

data/test/unit/parser/test_call.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -27,8 +27,60 @@
 class TestCall < Test::Unit::TestCase
   include Nasl::Test
 
+  def test_keyword_prefix
+    # We never want to have a function with the same name as a keyword.
+    fail_parse("break();")
+    fail_parse("continue();")
+    fail_parse("else();")
+    fail_parse("export();")
+    fail_parse("for();")
+    fail_parse("foreach();")
+    fail_parse("function();")
+    fail_parse("global_var();")
+    fail_parse("if();")
+    fail_parse("import();")
+    fail_parse("include();")
+    fail_parse("local_var();")
+    fail_parse("repeat();")
+    fail_parse("return();")
+    fail_parse("until();")
+    fail_parse("while();")
+
+    # We never want to have a function with the same name as a constant.
+    fail_parse("FALSE();")
+    fail_parse("NULL();")
+    fail_parse("TRUE();")
+
+    # 'in' and 'x' are exceptions. They are valid function names, despite being a keywords.
+    pass("in();")
+    pass("x();")
+
+    # Having a keyword at the start of a function name is perfectly valid.
+    pass("break_();")
+    pass("continue_();")
+    pass("else_();")
+    pass("export_();")
+    pass("for_();")
+    pass("foreach_();")
+    pass("function_();")
+    pass("global_var_();")
+    pass("if_();")
+    pass("import_();")
+    pass("include_();")
+    pass("local_var_();")
+    pass("repeat_();")
+    pass("return_();")
+    pass("until_();")
+    pass("while_();")
+
+    # Having a constant at the start of a function name is perfectly valid.
+    pass("FALSE_();")
+    pass("NULL_();")
+    pass("TRUE_();")
+  end
+
   def test_no_args
-    tree = parse("foo();")
+    tree = parse("foo[a][1]['b'][c+d].e.f.g();")
     assert_not_nil(tree)
 
     calls = tree.all(:Call)
@@ -41,7 +93,7 @@ class TestCall < Test::Unit::TestCase
   end
 
   def test_anonymous_args
-    tree = parse("foo(1, '2', three);")
+    tree = parse("foo[a][1]['b'][c+d].e.f.g(1, '2', three);")
     assert_not_nil(tree)
 
     calls = tree.all(:Call)
@@ -66,7 +118,7 @@ class TestCall < Test::Unit::TestCase
   end
 
   def test_named_args
-    tree = parse("foo(a:1, b:'2', c:three);")
+    tree = parse("foo[a][1]['b'][c+d].e.f.g(a:1, b:'2', c:three);")
     assert_not_nil(tree)
 
     calls = tree.all(:Call)
@@ -97,7 +149,7 @@ class TestCall < Test::Unit::TestCase
   end
 
   def test_mixed_args
-    tree = parse("foo(a:1, '2', c:three, bar());")
+    tree = parse("foo[a][1]['b'][c+d].e.f.g(a:1, '2', c:three, bar());")
     assert_not_nil(tree)
 
     calls = tree.all(:Call)

data/test/unit/parser/test_comment.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without

data/test/unit/parser/test_constant.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without

data/test/unit/parser/test_empty.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without

data/test/unit/parser/test_expressions.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -46,6 +46,13 @@ class TestExpressions < Test::Unit::TestCase
 
   def test_bitwise
     pass("q = 0 | 1;")
+    pass("q = 0 & 1;")
+  end
+
+  def test_period
+    pass("q = a.b;")
+    pass("q = a._;")
+    fail_parse("q = a.1");
   end
 
   def test_precedence

data/test/unit/parser/test_foreach.rb

@@ -0,0 +1,43 @@
+################################################################################
+# Copyright (c) 2011-2014, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+class TestForeach < Test::Unit::TestCase
+  include Nasl::Test
+
+  def test_old
+    same(
+      %q|foreach foo (bar);|,
+      '<tree><foreach><identifier name="foo"/><lvalue><identifier name="bar"/></lvalue><empty/></foreach></tree>'
+    )
+  end
+
+  def test_new
+    same(
+      %q|foreach (foo in bar);|,
+      '<tree><foreach><identifier name="foo"/><lvalue><identifier name="bar"/></lvalue><empty/></foreach></tree>'
+    )
+  end
+end

data/test/unit/parser/test_function.rb

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2012, Mak Kolybabi
+# Copyright (c) 2011-2014, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -28,55 +28,151 @@ class TestFunction < Test::Unit::TestCase
   include Nasl::Test
 
   def test_keyword_prefix
-    # While we never want to have a function with the same name as a keyword,
-    # having a keyword at the start of a function name is perfectly valid.
-    fail_parse("if();")
-    fail_parse("break();")
-    fail_parse("continue();")
-    fail_parse("else();")
-    fail_parse("export();")
-    fail_parse("for();")
-    fail_parse("foreach();")
-    fail_parse("function();")
-    fail_parse("global_var();")
-    fail_parse("if();")
-    fail_parse("import();")
-    fail_parse("include();")
-    fail_parse("local_var();")
-    fail_parse("repeat();")
-    fail_parse("return();")
-    fail_parse("until();")
-    fail_parse("while();")
-
-    # While we never want to have a function with the same name as a constant,
-    # having a constant at the start of a function name is perfectly valid.
-    fail_parse("FALSE();")
-    fail_parse("NULL();")
-    fail_parse("TRUE();")
-
-    # X is an exception. It is a valid function name, despite being a keyword.
-    pass("x();")
-
-    pass("if_();")
-    pass("break_();")
-    pass("continue_();")
-    pass("else_();")
-    pass("export_();")
-    pass("for_();")
-    pass("foreach_();")
-    pass("function_();")
-    pass("global_var_();")
-    pass("if_();")
-    pass("import_();")
-    pass("include_();")
-    pass("local_var_();")
-    pass("repeat_();")
-    pass("return_();")
-    pass("until_();")
-    pass("while_();")
-
-    pass("FALSE_();")
-    pass("NULL_();")
-    pass("TRUE_();")
+    # We never want to have a function with the same name as a keyword.
+    fail_parse("function break() {}")
+    fail_parse("function continue() {}")
+    fail_parse("function else() {}")
+    fail_parse("function export() {}")
+    fail_parse("function for() {}")
+    fail_parse("function foreach() {}")
+    fail_parse("function function() {}")
+    fail_parse("function global_var() {}")
+    fail_parse("function if() {}")
+    fail_parse("function import() {}")
+    fail_parse("function include() {}")
+    fail_parse("function local_var() {}")
+    fail_parse("function repeat() {}")
+    fail_parse("function return() {}")
+    fail_parse("function until() {}")
+    fail_parse("function while() {}")
+
+    # We never want to have a function with the same name as a constant.
+    fail_parse("function FALSE() {}")
+    fail_parse("function NULL() {}")
+    fail_parse("function TRUE() {}")
+
+    # 'in' and 'x' are exceptions. They are valid function names, despite being a keywords.
+    pass("function in() {}")
+    pass("function x() {}")
+
+    # Having a keyword at the start of a function name is perfectly valid.
+    pass("function break_() {}")
+    pass("function continue_() {}")
+    pass("function else_() {}")
+    pass("function export_() {}")
+    pass("function for_() {}")
+    pass("function foreach_() {}")
+    pass("function function_() {}")
+    pass("function global_var_() {}")
+    pass("function if_() {}")
+    pass("function import_() {}")
+    pass("function include_() {}")
+    pass("function local_var_() {}")
+    pass("function repeat_() {}")
+    pass("function return_() {}")
+    pass("function until_() {}")
+    pass("function while_() {}")
+
+    # Having a constant at the start of a function name is perfectly valid.
+    pass("function FALSE_() {}")
+    pass("function NULL_() {}")
+    pass("function TRUE_() {}")
+  end
+
+  def test_no_args
+    tree = parse("function foo() {}")
+    assert_not_nil(tree)
+
+    funcs = tree.all(:Function)
+    assert_not_nil(funcs)
+    assert_equal(1, funcs.length)
+
+    func = funcs.first
+    assert_not_nil(func)
+    assert_equal(0, func.params.length)
+  end
+
+  def test_named_args
+    tree = parse("function foo(a, b, c) {}")
+    assert_not_nil(tree)
+
+    funcs = tree.all(:Function)
+    assert_not_nil(funcs)
+    assert_equal(1, funcs.length)
+
+    func = funcs.first
+    assert_not_nil(func)
+    assert_equal(3, func.params.length)
+
+    param = func.params[0]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'a')
+    assert_equal(param.pass_by, 'value')
+
+    param = func.params[1]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'b')
+    assert_equal(param.pass_by, 'value')
+
+    param = func.params[2]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'c')
+    assert_equal(param.pass_by, 'value')
+  end
+
+  def test_reference_args
+    tree = parse("function foo(&a, &b, &c) {}")
+    assert_not_nil(tree)
+
+    funcs = tree.all(:Function)
+    assert_not_nil(funcs)
+    assert_equal(1, funcs.length)
+
+    func = funcs.first
+    assert_not_nil(func)
+    assert_equal(3, func.params.length)
+
+    param = func.params[0]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'a')
+    assert_equal(param.pass_by, 'reference')
+
+    param = func.params[1]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'b')
+    assert_equal(param.pass_by, 'reference')
+
+    param = func.params[2]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'c')
+    assert_equal(param.pass_by, 'reference')
+  end
+
+  def test_mixed_args
+    tree = parse("function foo(a, &b, c) {}")
+    assert_not_nil(tree)
+
+    funcs = tree.all(:Function)
+    assert_not_nil(funcs)
+    assert_equal(1, funcs.length)
+
+    func = funcs.first
+    assert_not_nil(func)
+    assert_equal(3, func.params.length)
+
+    param = func.params[0]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'a')
+    assert_equal(param.pass_by, 'value')
+
+    param = func.params[1]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'b')
+    assert_equal(param.pass_by, 'reference')
+
+    param = func.params[2]
+    assert(param.is_a? Nasl::Parameter)
+    assert_equal(param.name.name, 'c')
+    assert_equal(param.pass_by, 'value')
   end
 end