adlint 2.6.14 → 3.0.0

data/spec/adlint/{c → cc1}/ctrlexpr_spec.rb

@@ -2,7 +2,7 @@
 # iteration-statements.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -12,7 +12,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -33,45 +33,49 @@
 require "spec_helper"
 
 module AdLint
-module C
+module Cc1
 
   describe ControllingExpression do
-    before(:all) { Traits.instance.read_from($default_traits) }
+    include InterpreterMediator
+
+    before(:all) { @adlint = AdLint.new($default_traits) }
 
     before(:each) do
+      @monitor      = ProgressMonitor.new(nil, nil, false)
+      @logger       = Logger.new(File.open(File::NULL, "w"))
       @symbol_table = SymbolTable.new
-      @type_table = TypeTable.new
-      @interpreter = Interpreter.new(@type_table)
-      @int_i = @interpreter.define_variable(int_i_definition)
-      @int_j = @interpreter.define_variable(int_j_definition)
+      @type_table   = TypeTable.new(@adlint.traits, @monitor, @logger)
+      @interpreter  = Interpreter.new(@type_table)
+      @int_i        = @interpreter.define_variable(int_i_def)
+      @int_j        = @interpreter.define_variable(int_j_def)
     end
 
     context "`int i = ((> 0) && (< 10)) || (== 0)' and " +
             "`int j = ((> 0) && (< 10)) || (== 0)'" do
       before do
-        @int_i.narrow_value_domain!(Operator::GE, ScalarValue.of(0))
-        @int_i.narrow_value_domain!(Operator::LT, ScalarValue.of(10))
-        @int_j.narrow_value_domain!(Operator::GE, ScalarValue.of(0))
-        @int_j.narrow_value_domain!(Operator::LT, ScalarValue.of(10))
+        @int_i.narrow_value_domain!(Operator::GE, scalar_value_of(0))
+        @int_i.narrow_value_domain!(Operator::LT, scalar_value_of(10))
+        @int_j.narrow_value_domain!(Operator::GE, scalar_value_of(0))
+        @int_j.narrow_value_domain!(Operator::LT, scalar_value_of(10))
       end
 
       it "(i == j) makes that `i' should contain 0 and 9, " +
          "and should not contain 10" do
-        expr = EqualityExpression.new(eq_operator, i_specifier, j_specifier)
+        expr = EqualityExpression.new(eq_op, i_spec, j_spec)
         branched_eval(expr, NARROWING, FINAL) do
-          @int_i.value.may_be_equal_to?(ScalarValue.of(0)).should be_true
-          @int_i.value.may_be_equal_to?(ScalarValue.of(9)).should be_true
-          @int_i.value.may_be_equal_to?(ScalarValue.of(10)).should_not be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(0)).should be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(9)).should be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(10)).should_not be_true
         end
       end
 
       it "(i != j) makes that `i' should contain 0 and 9, " +
          "and should not contain 10" do
-        expr = EqualityExpression.new(ne_operator, i_specifier, j_specifier)
+        expr = EqualityExpression.new(ne_op, i_spec, j_spec)
         branched_eval(expr, NARROWING, FINAL) do
-          @int_i.value.may_be_equal_to?(ScalarValue.of(0)).should be_true
-          @int_i.value.may_be_equal_to?(ScalarValue.of(9)).should be_true
-          @int_i.value.may_be_equal_to?(ScalarValue.of(10)).should_not be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(0)).should be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(9)).should be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(10)).should_not be_true
         end
       end
     end
@@ -79,73 +83,71 @@ module C
     context "`int i = ((> 0) && (< 10)) || (== 0)' and " +
             "`int j = ((> 3) && (< 5)) || (== 3)'" do
       before do
-        @int_i.narrow_value_domain!(Operator::GE, ScalarValue.of(0))
-        @int_i.narrow_value_domain!(Operator::LT, ScalarValue.of(10))
-        @int_j.narrow_value_domain!(Operator::GE, ScalarValue.of(3))
-        @int_j.narrow_value_domain!(Operator::LT, ScalarValue.of(5))
+        @int_i.narrow_value_domain!(Operator::GE, scalar_value_of(0))
+        @int_i.narrow_value_domain!(Operator::LT, scalar_value_of(10))
+        @int_j.narrow_value_domain!(Operator::GE, scalar_value_of(3))
+        @int_j.narrow_value_domain!(Operator::LT, scalar_value_of(5))
       end
 
       it "(i == j) makes that `i' should contain 3 and 4, " +
          "and should not contain 0" do
-        expr = EqualityExpression.new(eq_operator, i_specifier, j_specifier)
+        expr = EqualityExpression.new(eq_op, i_spec, j_spec)
         branched_eval(expr, NARROWING, FINAL) do
-          @int_i.value.may_be_equal_to?(ScalarValue.of(3)).should be_true
-          @int_i.value.may_be_equal_to?(ScalarValue.of(4)).should be_true
-          @int_i.value.may_be_equal_to?(ScalarValue.of(0)).should_not be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(3)).should be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(4)).should be_true
+          @int_i.value.may_be_equal_to?(scalar_value_of(0)).should_not be_true
         end
       end
     end
 
-    include InterpreterMediator
-
     private
-    def eq_operator
+    def eq_op
       Token.new("==", "==", nil_loc)
     end
 
-    def ne_operator
+    def ne_op
       Token.new("!=", "!=", nil_loc)
     end
 
-    def i_specifier
-      object_specifier_of("i")
+    def i_spec
+      obj_spec_of("i")
     end
 
-    def j_specifier
-      object_specifier_of("j")
+    def j_spec
+      obj_spec_of("j")
     end
 
-    def object_specifier_of(name)
-      ObjectSpecifier.new(identifier_of(name))
+    def obj_spec_of(name)
+      ObjectSpecifier.new(id_of(name))
     end
 
-    def int_i_definition
-      uninitialized_int_vardef("i", @type_table.int_type)
+    def int_i_def
+      uninitialized_int_vardef("i", @type_table.int_t)
     end
 
-    def int_j_definition
-      uninitialized_int_vardef("j", @type_table.int_type)
+    def int_j_def
+      uninitialized_int_vardef("j", @type_table.int_t)
     end
 
     def uninitialized_int_vardef(name, type)
-      decl_specs = DeclarationSpecifiers.new.tap { |ds|
-        ds.type_specifiers.push(int_type_specifier)
+      dcl_specs = DeclarationSpecifiers.new.tap { |ds|
+        ds.type_specifiers.push(int_t_spec)
       }
-      decl = Declaration.new(decl_specs, [uninitialized_int_decl(name)],
+      decl = Declaration.new(dcl_specs, [uninitialized_int_dcl(name)],
                              @symbol_table)
       decl.items.each { |item| item.type = type }
       decl.items.find { |item| item.kind_of?(VariableDefinition) }
     end
 
-    def uninitialized_int_decl(name)
-      InitDeclarator.new(IdentifierDeclarator.new(identifier_of(name)), nil)
+    def uninitialized_int_dcl(name)
+      InitDeclarator.new(IdentifierDeclarator.new(id_of(name)), nil)
     end
 
-    def int_type_specifier
+    def int_t_spec
       StandardTypeSpecifier.new(Token.new(:INT, "int", Location.new))
     end
 
-    def identifier_of(name)
+    def id_of(name)
       Token.new(:IDENTIFIER, name, nil_loc)
     end
 

data/spec/adlint/{c → cc1}/domain_spec.rb

@@ -1,7 +1,7 @@
 # Unit specification of domain of values bound to variables.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -32,173 +32,177 @@
 require "spec_helper"
 
 module AdLint
-module C
+module Cc1
 
   describe ValueDomain do
+    include ArithmeticAccessor
+
+    before(:all) { @adlint = AdLint.new($default_traits) }
+
     describe EqualToValueDomain do
       context "(== -2147483648)" do
-        subject { ValueDomain.equal_to(-2147483648) }
+        subject { value_domain_equal_to(-2147483648) }
 
         it "should contain (== -2147483648)" do
-          subject.contain?(ValueDomain.equal_to(-2147483648)).should be_true
+          subject.contain?(value_domain_equal_to(-2147483648)).should be_true
         end
 
         it "should not contain (== 2147483647)" do
-          subject.contain?(ValueDomain.equal_to(2147483647)).should be_false
+          subject.contain?(value_domain_equal_to(2147483647)).should be_false
         end
       end
 
       context "(== 2147483647)" do
-        subject { ValueDomain.equal_to(2147483647) }
+        subject { value_domain_equal_to(2147483647) }
 
         it "should not contain (== -2147483648)" do
-          subject.contain?(ValueDomain.equal_to(-2147483648)).should be_false
+          subject.contain?(value_domain_equal_to(-2147483648)).should be_false
         end
       end
 
       context "(== 2)" do
-        subject { ValueDomain.equal_to(2) }
+        subject { value_domain_equal_to(2) }
 
         it "* (== 3) should be (== 6)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(== 6)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (== -6)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(== -6)"
         end
 
         it "* (< 3) should be (< 6)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(< 6)"
         end
 
         it "* (< 0) should be (< 0)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (< -3) should be (< -6)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(< -6)"
         end
 
         it "* (> 3) should be (> 6)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(> 6)"
         end
 
         it "* (> 0) should be (> 0)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (> -3) should be (> -6)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(> -6)"
         end
       end
 
       context "(== 0)" do
-        subject { ValueDomain.equal_to(0) }
+        subject { value_domain_equal_to(0) }
 
         it "* (== 3) should be (== 0)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (== 0)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (< 3) should be (== 0)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (< 0) should be (== 0)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (< -3) should be (== 0)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (> 3) should be (== 0)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (> 0) should be (== 0)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (> -3) should be (== 0)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(== 0)"
         end
       end
 
       context "(== -2)" do
-        subject { ValueDomain.equal_to(-2) }
+        subject { value_domain_equal_to(-2) }
 
         it "* (== 3) should be (== -6)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(== -6)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (== 6)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(== 6)"
         end
 
         it "* (< 3) should be (> -6)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(> -6)"
         end
 
         it "* (< 0) should be (> 0)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (< -3) should be (> 6)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(> 6)"
         end
 
         it "* (> 3) should be (< -6)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(< -6)"
         end
 
         it "* (> 0) should be (< 0)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (> -3) should be (< 6)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(< 6)"
         end
       end
@@ -206,157 +210,157 @@ module C
 
     describe LessThanValueDomain do
       context "(< 128)" do
-        subject { ValueDomain.less_than(128) }
+        subject { value_domain_less_than(128) }
 
         it "< (== 127) should be (== Unlimited)" do
-          rhs = ValueDomain.equal_to(127)
+          rhs = value_domain_equal_to(127)
           (subject < rhs).to_s.should == "(== Unlimited)"
         end
       end
 
       context "(< 2)" do
-        subject { ValueDomain.less_than(2) }
+        subject { value_domain_less_than(2) }
 
         it "* (== 3) should be (< 6)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(< 6)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (> -6)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(> -6)"
         end
 
         it "* (< 3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< 0) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< -3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (> 3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (> 0) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (> -3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
       end
 
       context "(< 0)" do
-        subject { ValueDomain.less_than(0) }
+        subject { value_domain_less_than(0) }
 
         it "* (== 3) should be (< 0)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (> 0)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (< 3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< 0) should be (> 0)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (< -3) should be (> 0)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (> 3) should be (< 0)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (> 0) should be (< 0)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (> -3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
       end
 
       context "(< -2)" do
-        subject { ValueDomain.less_than(-2) }
+        subject { value_domain_less_than(-2) }
 
         it "* (== 3) should be (< -6)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(< -6)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (> 6)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(> 6)"
         end
 
         it "* (< 3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< 0) should be (> 0)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (< -3) should be (> 6)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(> 6)"
         end
 
         it "* (> 3) should be (< -6)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(< -6)"
         end
 
         it "* (> 0) should be (< 0)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (> -3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
       end
@@ -364,157 +368,157 @@ module C
 
     describe GreaterThanValueDomain do
       context "(> -129)" do
-        subject { ValueDomain.greater_than(-129) }
+        subject { value_domain_greater_than(-129) }
 
         it "< (== 127) should be (== Unlimited)" do
-          rhs = ValueDomain.equal_to(127)
+          rhs = value_domain_equal_to(127)
           (subject < rhs).to_s.should == "(== Unlimited)"
         end
       end
 
       context "(> 2)" do
-        subject { ValueDomain.greater_than(2) }
+        subject { value_domain_greater_than(2) }
 
         it "* (== 3) should be (> 6)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(> 6)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (< -6)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(< -6)"
         end
 
         it "* (< 3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< 0) should be (< 0)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (< -3) should be (< -6)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(< -6)"
         end
 
         it "* (> 3) should be (> 6)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(> 6)"
         end
 
         it "* (> 0) should be (> 0)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (> -3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
       end
 
       context "(> 0)" do
-        subject { ValueDomain.greater_than(0) }
+        subject { value_domain_greater_than(0) }
 
         it "* (== 3) should be (> 0)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (< 0)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (< 3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< 0) should be (< 0)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (< -3) should be (< 0)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(< 0)"
         end
 
         it "* (> 3) should be (> 0)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (> 0) should be (> 0)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(> 0)"
         end
 
         it "* (> -3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
       end
 
       context "(> -2)" do
-        subject { ValueDomain.greater_than(-2) }
+        subject { value_domain_greater_than(-2) }
 
         it "* (== 3) should be (> -6)" do
-          rhs = ValueDomain.equal_to(3)
+          rhs = value_domain_equal_to(3)
           (subject * rhs).to_s.should == "(> -6)"
         end
 
         it "* (== 0) should be (== 0)" do
-          rhs = ValueDomain.equal_to(0)
+          rhs = value_domain_equal_to(0)
           (subject * rhs).to_s.should == "(== 0)"
         end
 
         it "* (== -3) should be (< 6)" do
-          rhs = ValueDomain.equal_to(-3)
+          rhs = value_domain_equal_to(-3)
           (subject * rhs).to_s.should == "(< 6)"
         end
 
         it "* (< 3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(3)
+          rhs = value_domain_less_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< 0) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (< -3) should be (== Unlimited)" do
-          rhs = ValueDomain.less_than(-3)
+          rhs = value_domain_less_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (> 3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(3)
+          rhs = value_domain_greater_than(3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (> 0) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
 
         it "* (> -3) should be (== Unlimited)" do
-          rhs = ValueDomain.greater_than(-3)
+          rhs = value_domain_greater_than(-3)
           (subject * rhs).to_s.should == "(== Unlimited)"
         end
       end
@@ -523,86 +527,86 @@ module C
     describe CompositeValueDomain do
       context "(== (((< 10) || (== 10)) && ((== -10) || (> -10))))" do
         subject do
-          tmp = ValueDomain.greater_than_or_equal_to(-10)
-          tmp.intersection(ValueDomain.less_than_or_equal_to(10))
+          tmp = value_domain_greater_than_or_equal_to(-10)
+          tmp.intersection(value_domain_less_than_or_equal_to(10))
         end
 
         it "should contain ((== -5) || (== 5))" do
-          rhs = ValueDomain.equal_to(-5).union(ValueDomain.equal_to(5))
+          rhs = value_domain_equal_to(-5).union(value_domain_equal_to(5))
           subject.contain?(rhs).should be_true
         end
       end
 
       context "((== -5) || (== 5))" do
-        subject { ValueDomain.equal_to(-5).union(ValueDomain.equal_to(5)) }
+        subject { value_domain_equal_to(-5).union(value_domain_equal_to(5)) }
 
         it "should not contain " +
            "(((< 10) || (== 10)) && ((== -10) || (> -10)))" do
-          rhs = ValueDomain.greater_than_or_equal_to(-10)
-          rhs = rhs.intersection(ValueDomain.less_than_or_equal_to(10))
+          rhs = value_domain_greater_than_or_equal_to(-10)
+          rhs = rhs.intersection(value_domain_less_than_or_equal_to(10))
           subject.contain?(rhs).should be_false
         end
 
         it "should be contained by " +
            "(((< 10) || (== 10)) && ((== -10) || (> -10)))" do
-          lhs = ValueDomain.greater_than_or_equal_to(-10)
-          lhs = lhs.intersection(ValueDomain.less_than_or_equal_to(10))
+          lhs = value_domain_greater_than_or_equal_to(-10)
+          lhs = lhs.intersection(value_domain_less_than_or_equal_to(10))
           lhs.contain?(subject).should be_true
         end
 
         it "intersection with (< 0) should be equal to (== -5)" do
-          rhs = ValueDomain.less_than(0)
+          rhs = value_domain_less_than(0)
           subject.intersection(rhs).to_s.should == "(== -5)"
         end
 
         it "intersection with (> 0) should be equal to (== 5)" do
-          rhs = ValueDomain.greater_than(0)
+          rhs = value_domain_greater_than(0)
           subject.intersection(rhs).to_s.should == "(== 5)"
         end
 
         it "intersection with ((== -10) || (> -10)) " +
            "should be equal to the subject domain" do
-          rhs = ValueDomain.greater_than_or_equal_to(-10)
+          rhs = value_domain_greater_than_or_equal_to(-10)
           subject.intersection(rhs).should == subject
         end
 
         it "intersection with ((== 10) || (< 10)) " +
            "should be equal to the subject domain" do
-          rhs = ValueDomain.less_than_or_equal_to(10)
+          rhs = value_domain_less_than_or_equal_to(10)
           subject.intersection(rhs).should == subject
         end
 
         it "should not contain (((< 0) && (> -10)) || (== -10))" do
-          rhs = ValueDomain.greater_than_or_equal_to(-10)
-          rhs = rhs.intersection(ValueDomain.less_than_or_equal_to(10))
-          rhs = rhs.intersection(ValueDomain.less_than(0))
+          rhs = value_domain_greater_than_or_equal_to(-10)
+          rhs = rhs.intersection(value_domain_less_than_or_equal_to(10))
+          rhs = rhs.intersection(value_domain_less_than(0))
           subject.contain?(rhs).should be_false
         end
       end
 
       context "(((< 0) && (> -10)) || (== -10))" do
         subject do
-          tmp = ValueDomain.greater_than_or_equal_to(-10)
-          tmp = tmp.intersection(ValueDomain.less_than_or_equal_to(10))
-          tmp.intersection(ValueDomain.less_than(0))
+          tmp = value_domain_greater_than_or_equal_to(-10)
+          tmp = tmp.intersection(value_domain_less_than_or_equal_to(10))
+          tmp.intersection(value_domain_less_than(0))
         end
 
         it "should not contain ((== -5) || (== 5))" do
-          rhs = ValueDomain.equal_to(-5).union(ValueDomain.equal_to(5))
+          rhs = value_domain_equal_to(-5).union(value_domain_equal_to(5))
           subject.contain?(rhs).should be_false
         end
       end
 
       context "(((< 0) && (> -2147483647)) || (== 0))" do
         subject do
-          tmp = ValueDomain.less_than_or_equal_to(0)
-          tmp.intersection(ValueDomain.greater_than_or_equal_to(-2147483647))
+          tmp = value_domain_less_than_or_equal_to(0)
+          tmp.intersection(value_domain_greater_than_or_equal_to(-2147483647))
         end
 
         it "union with ((== -2147483647) || (== 0)) should be " +
            "((((< 0) && (> -2147483647)) || (== -2147483647)) || (== 0))" do
-          rhs = ValueDomain.equal_to(-2147483647)
-          rhs = rhs.union(ValueDomain.equal_to(0))
+          rhs = value_domain_equal_to(-2147483647)
+          rhs = rhs.union(value_domain_equal_to(0))
           subject.union(rhs).to_s.should ==
             "((((< 0) && (> -2147483647)) || (== -2147483647)) || (== 0))"
         end
@@ -610,29 +614,29 @@ module C
 
       context "((== -2147483647) || (== 0))" do
         subject do
-          ValueDomain.equal_to(-2147483647).union(ValueDomain.equal_to(0))
+          value_domain_equal_to(-2147483647).union(value_domain_equal_to(0))
         end
 
         it "should contain ((== -2147483647) || (== 0))" do
-          rhs = ValueDomain.equal_to(-2147483647)
-          rhs = rhs.union(ValueDomain.equal_to(0))
+          rhs = value_domain_equal_to(-2147483647)
+          rhs = rhs.union(value_domain_equal_to(0))
           subject.contain?(rhs).should be_true
         end
 
         it "should contain (== -2147483647)" do
-          subject.contain?(ValueDomain.equal_to(-2147483647)).should be_true
+          subject.contain?(value_domain_equal_to(-2147483647)).should be_true
         end
 
         it "should contain (== 0)" do
-          subject.contain?(ValueDomain.equal_to(0)).should be_true
+          subject.contain?(value_domain_equal_to(0)).should be_true
         end
       end
 
       context "(((< 2147483647) && (> -2147483648)) || (== 2147483647))" do
         subject do
-          tmp = ValueDomain.greater_than(-2147483648)
-          tmp = tmp.intersection(ValueDomain.less_than(2147483647))
-          tmp.union(ValueDomain.equal_to(2147483647))
+          tmp = value_domain_greater_than(-2147483648)
+          tmp = tmp.intersection(value_domain_less_than(2147483647))
+          tmp.union(value_domain_equal_to(2147483647))
         end
 
         it "cloned should be " +
@@ -656,15 +660,15 @@ module C
 
       context "(((< 2147483647) && (> 1)) || (== 1))" do
         subject do
-          tmp = ValueDomain.greater_than(1)
-          tmp = tmp.intersection(ValueDomain.less_than(2147483647))
-          tmp.union(ValueDomain.equal_to(1))
+          tmp = value_domain_greater_than(1)
+          tmp = tmp.intersection(value_domain_less_than(2147483647))
+          tmp.union(value_domain_equal_to(1))
         end
 
         it "union with ((== 1) || (== 2147483647)) should be " +
            "(((< 2147483647) && (> 1)) || ((== 1) || (== 2147483647)))" do
-          rhs = ValueDomain.equal_to(1)
-          rhs = rhs.union(ValueDomain.equal_to(2147483647))
+          rhs = value_domain_equal_to(1)
+          rhs = rhs.union(value_domain_equal_to(2147483647))
           subject.union(rhs).to_s.should ==
             "(((< 2147483647) && (> 1)) || ((== 1) || (== 2147483647)))"
         end
@@ -672,21 +676,23 @@ module C
 
       context "(((< 429) && (> 0)) || (== 429))" do
         subject do
-          tmp = ValueDomain.greater_than(0)
-          tmp = tmp.intersection(ValueDomain.less_than(429))
-          tmp.union(ValueDomain.equal_to(429))
+          tmp = value_domain_greater_than(0)
+          tmp = tmp.intersection(value_domain_less_than(429))
+          tmp.union(value_domain_equal_to(429))
         end
 
         it "intersection with (== 0) should be (== Nil)" do
-          subject.intersection(ValueDomain.equal_to(0)).to_s.should ==
+          subject.intersection(value_domain_equal_to(0)).to_s.should ==
             "(== Nil)"
         end
       end
 
       context "(((< 10) || (== 10)) && ((== 0) || (> 0)))" do
         subject do
-          ValueDomain.of_intersection(ValueDomain.greater_than_or_equal_to(0),
-                                      ValueDomain.less_than_or_equal_to(10))
+          ValueDomain.of_intersection(
+            value_domain_greater_than_or_equal_to(0),
+            value_domain_less_than_or_equal_to(10)
+          )
         end
 
         it "+ (((< 10) || (== 10)) && ((== 0) || (> 0))) " +
@@ -698,53 +704,53 @@ module C
 
       context "((((< 10) && (> -10)) || (== 10)) || (== -10))" do
         subject do
-          tmp = ValueDomain.greater_than_or_equal_to(-10)
-          tmp.intersection(ValueDomain.less_than_or_equal_to(10))
+          tmp = value_domain_greater_than_or_equal_to(-10)
+          tmp.intersection(value_domain_less_than_or_equal_to(10))
         end
 
         it "should intersect with (== 0)" do
-          subject.intersect?(ValueDomain.equal_to(0)).should be_true
+          subject.intersect?(value_domain_equal_to(0)).should be_true
         end
 
         it "< (== 0) should be (== Unlimited)" do
-          (subject < ValueDomain.equal_to(0)).to_s.should == "(== Unlimited)"
+          (subject < value_domain_equal_to(0)).to_s.should == "(== Unlimited)"
         end
 
         it "> (== 0) should be (== Unlimited)" do
-          (subject > ValueDomain.equal_to(0)).to_s.should == "(== Unlimited)"
+          (subject > value_domain_equal_to(0)).to_s.should == "(== Unlimited)"
         end
 
         it "== (== 0) should be (== Unlimited)" do
-          (subject == ValueDomain.equal_to(0)).to_s.should == "(== Unlimited)"
+          (subject == value_domain_equal_to(0)).to_s.should == "(== Unlimited)"
         end
 
         it "!= (== 0) should be (== Unlimited)" do
-          (subject != ValueDomain.equal_to(0)).to_s.should == "(== Unlimited)"
+          (subject != value_domain_equal_to(0)).to_s.should == "(== Unlimited)"
         end
 
         it "< (== 20) should be ((< 0) || (> 0))" do
-          (subject < ValueDomain.equal_to(20)).to_s.should ==
+          (subject < value_domain_equal_to(20)).to_s.should ==
             "((< 0) || (> 0))"
         end
 
         it "> (== 20) should be (== 0)" do
-          (subject > ValueDomain.equal_to(20)).to_s.should == "(== 0)"
+          (subject > value_domain_equal_to(20)).to_s.should == "(== 0)"
         end
       end
 
       context "(((< 11) && (> 1)) || (== 11))" do
         subject do
-          tmp = ValueDomain.greater_than(1)
-          tmp = tmp.intersection(ValueDomain.less_than(11))
-          tmp.union(ValueDomain.equal_to(11))
+          tmp = value_domain_greater_than(1)
+          tmp = tmp.intersection(value_domain_less_than(11))
+          tmp.union(value_domain_equal_to(11))
         end
 
         it "narrowed by == ((((< 10) && (> 0)) || (== 10)) || (== 0)) " +
            "should be (((< 10) && (> 1)) || (== 10))" do
-          rhs = ValueDomain.greater_than(0)
-          rhs = rhs.intersection(ValueDomain.less_than(10))
-          rhs = rhs.union(ValueDomain.equal_to(0))
-          rhs = rhs.union(ValueDomain.equal_to(10))
+          rhs = value_domain_greater_than(0)
+          rhs = rhs.intersection(value_domain_less_than(10))
+          rhs = rhs.union(value_domain_equal_to(0))
+          rhs = rhs.union(value_domain_equal_to(10))
           subject.narrow(Operator::EQ, rhs).to_s.should ==
             "(((< 10) && (> 1)) || (== 10))"
         end
@@ -752,30 +758,30 @@ module C
 
       context "((< 128) && (> -129))" do
         subject do
-          tmp = ValueDomain.greater_than(-129)
-          tmp.intersection(ValueDomain.less_than(128))
+          tmp = value_domain_greater_than(-129)
+          tmp.intersection(value_domain_less_than(128))
         end
 
         it "should intersect with (== -128)" do
-          subject.intersect?(ValueDomain.equal_to(-128)).should be_true
+          subject.intersect?(value_domain_equal_to(-128)).should be_true
         end
 
         it "should intersect with (== 127)" do
-          subject.intersect?(ValueDomain.equal_to(127)).should be_true
+          subject.intersect?(value_domain_equal_to(127)).should be_true
         end
       end
 
       context "((((< 2147483647) && (> -2147483648)) || " +
               "(== 2147483647)) || (== -2147483648))" do
         subject do
-          tmp = ValueDomain.greater_than_or_equal_to(-2147483648)
-          tmp.intersection(ValueDomain.less_than_or_equal_to(2147483647))
+          tmp = value_domain_greater_than_or_equal_to(-2147483648)
+          tmp.intersection(value_domain_less_than_or_equal_to(2147483647))
         end
 
         it "narrowed by != (== 1) should be " +
            "(((((< 1) && (> -2147483648)) || ((< 2147483647) && (> 1))) || " +
            "(== 2147483647)) || (== -2147483648))" do
-          subject.narrow(Operator::NE, ValueDomain.equal_to(1)).to_s.should ==
+          subject.narrow(Operator::NE, value_domain_equal_to(1)).to_s.should ==
             "(((((< 1) && (> -2147483648)) || ((< 2147483647) && (> 1))) || " +
             "(== 2147483647)) || (== -2147483648))"
         end
@@ -783,8 +789,8 @@ module C
 
       context "(((< 10) && (> 0)) || (== 0))" do
         subject do
-          tmp = ValueDomain.greater_than_or_equal_to(0)
-          tmp.intersection(ValueDomain.less_than(10))
+          tmp = value_domain_greater_than_or_equal_to(0)
+          tmp.intersection(value_domain_less_than(10))
         end
 
         it "narrowed by != its cloned should be (== Nil)" do
@@ -794,41 +800,66 @@ module C
 
       context "((< 10) && (> 0))" do
         subject do
-          tmp = ValueDomain.greater_than(0)
-          tmp.intersection(ValueDomain.less_than(10))
+          tmp = value_domain_greater_than(0)
+          tmp.intersection(value_domain_less_than(10))
         end
 
         it "+ ((< 10) && (> 0)) should be ((< 10) && (> 0))" do
-          rhs = ValueDomain.greater_than(0)
-          rhs = rhs.intersection(ValueDomain.less_than(10))
+          rhs = value_domain_greater_than(0)
+          rhs = rhs.intersection(value_domain_less_than(10))
           (subject + rhs).to_s.should == "((< 20) && (> 0))"
         end
 
         it "* (== 2) should be ((< 20) && (> 0))" do
-          rhs = ValueDomain.equal_to(2)
+          rhs = value_domain_equal_to(2)
           (subject * rhs).to_s.should == "((< 20) && (> 0))"
         end
 
         it "* ((< 10) && (> 0)) should be ((< 100) && (> 0))" do
-          rhs = ValueDomain.greater_than(0)
-          rhs = rhs.intersection(ValueDomain.less_than(10))
+          rhs = value_domain_greater_than(0)
+          rhs = rhs.intersection(value_domain_less_than(10))
           (subject * rhs).to_s.should == "((< 100) && (> 0))"
         end
 
         it "/ (== 2) should be ((< 5) && (> 0))" do
-          rhs = ValueDomain.equal_to(2)
+          rhs = value_domain_equal_to(2)
           (subject / rhs).to_s.should == "((< 5) && (> 0))"
         end
 
         # TODO: Fix bad value-domain division before 1.14.0 GA release.
         #it "/ ((< 10) && (> 0)) should be ((< 10) && (> 0))" do
-        #  rhs = ValueDomain.greater_than(0)
-        #  rhs = rhs.intersection(ValueDomain.less_than(10))
+        #  rhs = value_domain_greater_than(0)
+        #  rhs = rhs.intersection(value_domain_less_than(10))
         #  File.open("dump", "w") { |io| PP.pp(subject / rhs, io) }
         #  (subject / rhs).to_s.should == "((< 10) && (> 0))"
         #end
       end
     end
+
+    private
+    def value_domain_equal_to(val)
+      ValueDomain.equal_to(val, logical_right_shift?)
+    end
+
+    def value_domain_less_than(val)
+      ValueDomain.less_than(val, logical_right_shift?)
+    end
+
+    def value_domain_greater_than(val)
+      ValueDomain.greater_than(val, logical_right_shift?)
+    end
+
+    def value_domain_less_than_or_equal_to(val)
+      ValueDomain.less_than_or_equal_to(val, logical_right_shift?)
+    end
+
+    def value_domain_greater_than_or_equal_to(val)
+      ValueDomain.greater_than_or_equal_to(val, logical_right_shift?)
+    end
+
+    def traits
+      @adlint.traits
+    end
   end
 
 end