yaparc 0.2.2 → 0.2.3

data/test/n3.bnf

@@ -0,0 +1,129 @@
+#
+#  Taken from http://www.w3.org/DesignIssues/Notation3.html
+#  on 2001-08-03 (version of 2001-04-10)
+#
+#  Modifications:
+#     
+# $Log: n3.bnf,v $
+# Revision 1.4  2001/08/06 20:56:21  sandro
+# added space* and space+ in several places
+# removed "#" from forbidden chars in URI_Reference
+# handles comments
+# made directives actually part of the grammar (!)
+# allowed nprefix to be zero-length
+#
+# Revision 1.3  2001/08/03 13:44:43  sandro
+# filled in remaining non-terminals
+#
+# Revision 1.2  2001/08/03 13:02:48  sandro
+# standardized BNF so blindfold can compile it
+#    added ::= for each rule
+#    added | for branches
+#    added ; at end of rule
+#    added # before comments
+#    put quotes around literals
+#    turn hypen into underscore in identifiers
+#    rename prefix to nprefix (hack around blindfold keyword for now)
+#
+# Revision 1.1  2001/08/03 12:34:38  sandro
+# added opening comments
+#
+
+
+document ::= void 
+	   | statementlist;
+
+space ::= " " | "\n" | "\r" | comment;
+
+comment ::= "#" [^\r\n]*;
+
+statement ::= subject space+ property_list
+	    | directive
+	    ;
+
+statementlist ::= (statement space* ("." space*)?)* ;
+
+subject ::= node;
+
+verb ::= ">-" prop "->"    # has xxx of 
+       | "<-" prop "<-"    # is xxx of 
+    #  | operator          # has operator:xxx of??? NOT IMPLMENTED
+       | prop              # has xxx of -- shorthand
+       | "has" prop        # has xxx of
+       | "is" prop "of"    # is xxx of
+       | "a"               # has rdf:type of
+       | "="		   # has daml:equivaent of
+       ;
+
+prop ::= node;
+
+node ::= uri_ref2 
+       | anonnode
+       | "this"
+       | node 
+       ;
+
+nodelist ::= void    # (used in lists) 
+	   | node
+	   | node nodelist
+	   ;
+
+anonnode ::= "[" property_list "]"  # something which ...
+	   | "{" statementlist "}"  # the statementlist itself as a resource
+	   | "(" nodelist ")"       # short for eg [ n3:first node1; n3:rest [ n3:first node2; n3:rest: n3:null ]]
+	   ;
+
+property_list ::= void   # to allow [...]. 
+	        | verb space+ object_list
+		| verb space+ object_list space+ ";" space+ property_list
+		| ":-" anonnode  #to allow two anonymous forms to be given eg [ a :Truth; :- { :sky :color :blue } ] )
+		| ":-" anonnode ";" property_list
+		;
+
+object_list ::= object 
+	      | object "," object_list
+	      ;
+
+uri_ref2 ::= qname 
+	   | "<" URI_Reference ">"
+	   ;
+
+qname ::= nprefix ":" localname; # ??? Allow omit colon when prefix void - keyword clash 
+
+object ::= subject 
+         | string1 # " constant-value-with-escaping "
+	 | string2 # """ constant value with escaping including single or double occurences of quotes and/or newlines """
+	 #      well-formed-xml-element ???? legacy or structured stuff - not implemented or distinguished
+	 ;
+
+directive ::= "bind" space+ nprefix ":" uri_ref2   # Namespace declartion. Trailing "#" is omitted & assumed. Obsolete.
+	    | "@prefix" space+ nprefix ":" space+ uri_ref2  # Namespace declaration
+	    ;
+
+# operator ::=  (Not implemented) 
+#      + >- operator:plus -> 
+#      - >- operator:minus ->
+#      / >- operator:slash->
+#      * >- operator:star-> (etc? @@)
+
+fragid ::= alpha alphanumeric* ;
+
+alpha ::= [a-zA-Z];
+
+alphanumeric ::= alpha | [0-9] | "_";
+
+void ::= "" ;   # nothing
+
+URI_Reference ::= [^{}<>]*;    # short version
+
+nprefix ::= "" | ((alpha | "_") alphanumeric*);
+
+localname ::= fragid;
+
+string1 ::= '"' string1_char* '"';
+
+string1_char ::= '\\"' | [^\"] ;           # should disallow some other characters, etc.
+
+string2 ::= '"""' string2_char* '"""';
+
+string2_char ::= [^"] | ([^] [^] [^"]);    # something like this; need to think about it some more

data/{tests → test}/test_calc.rb

@@ -7,7 +7,7 @@ module Calc
     include Yaparc::Parsable
     
     def initialize
-      @parser = lambda do
+      @parser = lambda do |input|
         Yaparc::Alt.new(
                         Yaparc::Seq.new(Term.new,
                                         Yaparc::Symbol.new('+'),
@@ -48,7 +48,7 @@ module Calc
     include Yaparc::Parsable
 
     def initialize
-      @parser = lambda do
+      @parser = lambda do |input|
         Yaparc::Alt.new(
                         Yaparc::Seq.new(Factor.new,
                                         Yaparc::Symbol.new('*'),
@@ -64,7 +64,7 @@ module Calc
     include Yaparc::Parsable
 
     def initialize
-      @parser = lambda do
+      @parser = lambda do |input|
         Yaparc::Alt.new(
                         Yaparc::Seq.new(
                                         Yaparc::Symbol.new('('),

data/test/test_lambda.rb

@@ -0,0 +1,87 @@
+require 'lib/yaparc.rb'
+require 'test/unit'
+
+=begin
+<expression> ::= <identifier>
+             ::= "(" lambda (<identifier> <expression> ")"
+             ::= "(" <expression> <expression> ")"
+=end
+
+module LambdaParser
+
+
+  class Identifier
+    include Yaparc::Parsable
+    RESERVED = %w{lambda}
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Identifier.new(:exclude => RESERVED)
+      end
+    end
+  end
+
+  # KEYWORDS = %w{lambda}
+  # <expression> ::= <identifier>
+  class Expression
+    include Yaparc::Parsable
+    OPEN_PAREN = Yaparc::String.new("(")
+    CLOSE_PAREN = Yaparc::String.new(")")
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Alt.new(#<identifier>
+                        Identifier.new,
+                        #"(" lambda "(" <identifier> ")" <expression> ")"
+                        Yaparc::Seq.new(OPEN_PAREN,
+                                        Yaparc::String.new("lambda"),
+                                        Yaparc::Tokenize.new(OPEN_PAREN),
+                                        Identifier.new,
+                                        CLOSE_PAREN,
+                                        Expression.new),
+                        #"(" <expression> <expression> ")"
+                        Yaparc::Seq.new(OPEN_PAREN,
+                                        Expression.new,
+                                        Expression.new,
+                                        CLOSE_PAREN))
+      end
+    end
+  end
+end # of LambdaParser
+
+
+class LambdaIdentifierParserTest < Test::Unit::TestCase
+  include ::Yaparc
+
+  def setup
+    @parser = LambdaParser::Identifier.new
+  end
+
+  def test_identifier
+    result = @parser.parse("identifier")
+    assert_instance_of Result::OK, result
+    result = @parser.parse("lambda")
+    assert_instance_of Result::Fail, result
+
+    result = @parser.parse(" identifier")
+    assert_instance_of Result::OK, result
+    result = @parser.parse(" identifier ")
+    assert_instance_of Result::OK, result
+    result = @parser.parse("identifier ")
+    assert_instance_of Result::OK, result
+  end
+end
+
+class LambdaExpressionParserTest < Test::Unit::TestCase
+  include ::Yaparc
+
+  def setup
+    @parser = LambdaParser::Expression.new
+  end
+
+  def test_expression
+    assert_instance_of Result::OK, @parser.parse("identifier")
+    assert_instance_of Result::OK, @parser.parse("(lambda (x) x)")
+    assert_instance_of Result::OK, @parser.parse("(apply argument)")
+  end
+end

data/test/test_metric.rb

@@ -0,0 +1,617 @@
+require 'lib/yaparc.rb'
+require 'test/unit'
+
+
+=begin Metric Interchange Syntax
+
+c.f. http://people.csail.mit.edu/jaffer/MIXF/MIXF-08
+Here is a YACC-like syntax for metric quantities (with [ISO 6093] numbers).
+
+
+ quantity_value
+        : numerical_value
+        | numerical_value '.' unit
+        ;
+
+ unit
+        : unit_product
+        | unit_product '/' single_unit
+        ;
+
+ unit_product
+        : single_unit
+        | unit_product '.' single_unit
+        ;
+
+ single_unit
+        : punit
+        | punit '^' uxponent
+        | '(' unit ')'
+        | '(' unit ')^' uxponent
+        ;
+
+ uxponent
+        : uinteger
+        | '-' uinteger
+        | '(' uinteger '/' uinteger ')'
+        | '(-' uinteger '/' uinteger ')'
+        ;
+
+ punit
+        : decimal_multiple_prefix unit_p_symbol
+        | decimal_submultiple_prefix unit_n_symbol
+        | decimal_multiple_prefix unit_b_symbol
+        | decimal_submultiple_prefix unit_b_symbol
+        | binary_prefix 'B'
+        | binary_prefix 'bit'
+        | unit_p_symbol
+        | unit_n_symbol
+        | unit_b_symbol
+        | unit___symbol
+        ;
+
+ decimal_multiple_prefix
+        : 'E' | 'G' | 'M' | 'P' | 'T' | 'Y' | 'Z' | 'da' | 'h' | 'k'
+        ;
+
+ decimal_submultiple_prefix
+        : 'a' | 'c' | 'd' | 'f' | 'm' | 'n' | 'p' | 'u' | 'y' | 'z'
+        ;
+
+ binary_prefix
+        : 'Ei' | 'Gi' | 'Ki' | 'Mi' | 'Pi' | 'Ti'
+        ;
+
+ unit_p_symbol
+        : 'B' | 'Bd' | 'r' | 't'
+        ;
+
+ unit_n_symbol
+        : 'L' | 'Np' | 'o' | 'oC' | 'rad' | 'sr'
+        ;
+
+ unit_b_symbol
+        : 'A' | 'Bq' | 'C' | 'F' | 'Gy' | 'H' | 'Hz' | 'J' | 'K' | 'N'
+        | 'Ohm' | 'Pa' | 'S' | 'Sv' | 'T' | 'V' | 'W' | 'Wb' | 'bit'
+        | 'cd' | 'eV' | 'g' | 'kat' | 'lm' | 'lx' | 'm' | 'mol' | 's'
+        ;
+
+ unit___symbol
+        : 'd' | 'dB' | 'h' | 'min' | 'u'
+        ;
+
+ real
+        : ureal
+        | '-' ureal
+        ;
+
+ ureal
+        : numerical_value
+        | numerical_value suffix
+        ;
+
+ numerical_value
+        : uinteger
+        | dot uinteger
+        | uinteger dot uinteger
+        | uinteger dot
+        ;
+
+ dot
+        : '.' | ','
+        ;
+
+ uinteger
+        : digit uinteger
+        | uinteger
+        ;
+
+ suffix
+        : exponent_marker uinteger
+        | exponent_marker '-' uinteger
+        ;
+
+ exponent_marker
+        : 'e' | 'E'
+        ;
+
+ digit
+        : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+        ;
+
+=end
+
+
+module MISParser
+
+=begin
+ quantity_value
+        : numerical_value ['.' unit]*
+        ;
+=end
+  class QuantityValue
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Seq.new(NumericalValue.new,
+                        Yaparc::ZeroOne.new(
+                                            Yaparc::Seq.new(Yaparc::Literal.new('.'),Unit.new)))
+      end
+    end
+  end
+
+
+=begin
+ unit
+        : unit_product ['/' single_unit]*
+        ;
+=end
+  class Unit
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Seq.new(UnitProduct.new,
+                        Yaparc::ZeroOne.new(
+                                            Yaparc::Seq.new(Yaparc::Literal.new('/'),SingleUnit.new)))
+      end
+    end
+  end
+
+=begin
+ unit_product
+        : single_unit [unit_product '.' single_unit]*
+        ;
+=end
+  class UnitProduct
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Seq.new(SingleUnit.new,
+                        Yaparc::ZeroOne.new(
+                                            Yaparc::Seq.new(UnitProduct.new, Yaparc::Literal.new('.'), SingleUnit.new)))
+      end
+    end
+  end
+
+=begin
+ single_unit
+        : punit
+        | punit '^' uxponent
+        | '(' unit ')'
+        | '(' unit ')^' uxponent
+        ;
+=end
+  class SingleUnit
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Alt.new(
+                        Yaparc::Seq.new(Punit.new,Yaparc::Literal.new('^'),Uxponent.new),
+                        Punit.new,
+                        Yaparc::Seq.new(Yaparc::Literal.new('('),Unit.new,Yaparc::Literal.new(')^'),Uxponent.new),
+                        Yaparc::Seq.new(Yaparc::Literal.new('('),Unit.new,Yaparc::Literal.new(')')))
+      end
+    end
+  end
+
+=begin
+ uxponent
+        : uinteger
+        | '-' uinteger
+        | '(' uinteger '/' uinteger ')'
+        | '(-' uinteger '/' uinteger ')'
+        ;
+=end
+  class Uxponent
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Alt.new(
+                        Uinteger.new,
+                        Yaparc::Seq.new(Yaparc::Literal.new('-'),Uinteger.new),
+                        Yaparc::Seq.new(Yaparc::Literal.new('('),Uinteger.new,Yaparc::Literal.new('/'),Uinteger.new,Yaparc::Literal.new(')')),
+                        Yaparc::Seq.new(Yaparc::Literal.new('(-'),Uinteger.new,Yaparc::Literal.new('/'),Uinteger.new,Yaparc::Literal.new(')')))
+      end
+    end
+  end
+
+=begin
+ punit
+        : decimal_multiple_prefix unit_p_symbol
+        | decimal_submultiple_prefix unit_n_symbol
+        | decimal_multiple_prefix unit_b_symbol
+        | decimal_submultiple_prefix unit_b_symbol
+        | binary_prefix 'B'
+        | binary_prefix 'bit'
+        | unit_p_symbol
+        | unit_n_symbol
+        | unit_b_symbol
+        | unit___symbol
+        ;
+=end
+  class Punit
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Alt.new(
+                        Yaparc::Seq.new(DecimalMultiplePrefix.new, UnitPSymbol.new),
+                        Yaparc::Seq.new(DecimalSubmultiplePrefix.new, UnitNSymbol.new),
+                        Yaparc::Seq.new(DecimalMultiplePrefix.new, UnitBSymbol.new),
+                        Yaparc::Seq.new(DecimalSubmultiplePrefix.new, UnitBSymbol.new),
+                        Yaparc::Seq.new(BinaryPrefix.new, Yaparc::Literal.new('B')),
+                        Yaparc::Seq.new(BinaryPrefix.new, Yaparc::Literal.new('bit')),
+                        UnitPSymbol.new,
+                        UnitNSymbol.new,
+                        UnitBSymbol.new,
+                        UnitSymbol.new)
+                                        
+
+      end
+    end
+  end
+
+
+=begin
+ decimal_multiple_prefix
+=end
+  class DecimalMultiplePrefix
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\AE|G|M|P|T|Y|Z|da|h|k/)
+      end
+    end
+  end
+
+=begin
+ decimal_submultiple_prefix
+        : 'a' | 'c' | 'd' | 'f' | 'm' | 'n' | 'p' | 'u' | 'y' | 'z'
+        ;
+=end
+  class DecimalSubmultiplePrefix
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\A[acdfmnpuyz]/)
+      end
+    end
+  end
+
+=begin
+ binary_prefix
+        : 'Ei' | 'Gi' | 'Ki' | 'Mi' | 'Pi' | 'Ti'
+        ;
+=end
+  class BinaryPrefix
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\AEi|Gi|Ki|Mi|Pi|Ti/)
+      end
+    end
+  end
+
+=begin
+ unit_p_symbol
+        : 'B' | 'Bd' | 'r' | 't'
+        ;
+=end
+  class UnitPSymbol
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\ABd|B|r|t/)
+      end
+    end
+  end
+
+=begin
+ unit_n_symbol
+        : 'L' | 'Np' | 'o' | 'oC' | 'rad' | 'sr'
+        ;
+=end
+  class UnitNSymbol
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\AL|Np|o|oC|rad|sr/)
+      end
+    end
+  end
+
+=begin
+ unit_b_symbol
+        : 'A' | 'Bq' | 'C' | 'F' | 'Gy' | 'H' | 'Hz' | 'J' | 'K' | 'N'
+        | 'Ohm' | 'Pa' | 'S' | 'Sv' | 'T' | 'V' | 'W' | 'Wb' | 'bit'
+        | 'cd' | 'eV' | 'g' | 'kat' | 'lm' | 'lx' | 'm' | 'mol' | 's'
+        ;
+=end
+  class UnitBSymbol
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\AA|Bq|C|F|Gy|H|Hz|J|K|N|Ohm|Pa|S|Sv|T|V|W|Wb|bit|cd|eV|g|kat|lm|lx|m|mol|s/)
+      end
+    end
+  end
+
+=begin
+ unit___symbol
+        : 'd' | 'dB' | 'h' | 'min' | 'u'
+        ;
+=end
+  class UnitSymbol
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\Ad|dB|h|min|u/)
+      end
+    end
+  end
+
+=begin
+ real
+        : ureal
+        | '-' ureal
+        ;
+=end
+  class Real
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Seq.new(Yaparc::ZeroOne.new(Yaparc::Literal.new('-'),""),Ureal.new)
+      end
+    end
+  end
+
+=begin
+ ureal
+        : numerical_value
+        | numerical_value suffix
+        ;
+=end
+  class Ureal
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Seq.new(NumericalValue.new, Yaparc::ZeroOne.new(Suffix.new,""))
+      end
+    end
+  end
+
+=begin
+ numerical_value
+        : uinteger
+        | dot uinteger
+        | uinteger dot uinteger
+        | uinteger dot
+        ;
+=end
+
+  class NumericalValue
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Alt.new(Uinteger.new,
+                        Yaparc::Seq.new(Dot.new,Uinteger.new),
+                        Yaparc::Seq.new(Uinteger.new, Dot.new, Yaparc::ZeroOne.new(Uinteger.new,"")))
+      end
+    end
+  end
+
+=begin
+ dot
+        : '.' | ','
+        ;
+=end
+
+  class Dot
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\A[.,]/)
+      end
+    end
+  end
+
+=begin
+ suffix
+        : exponent_marker uinteger
+        | exponent_marker '-' uinteger
+        ;
+=end
+
+  class Suffix
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Seq.new(ExponentMarker.new,
+                        Yaparc::ZeroOne.new(Yaparc::Literal.new('-'),''),
+                        Uinteger.new)
+      end
+    end
+  end
+
+
+=begin
+ uinteger
+        : [digit]+
+        ;
+=end
+  class Uinteger
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::ManyOne.new(Digit.new,'')
+      end
+    end
+  end
+
+
+=begin
+ exponent_marker
+        : 'e' | 'E'
+        ;
+=end
+
+  class ExponentMarker
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\A[eE]/)
+      end
+    end
+  end
+
+=begin
+ digit
+        : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+        ;
+=end
+
+  class Digit
+    include Yaparc::Parsable
+
+    def initialize
+      @parser = lambda do |input|
+        Yaparc::Regex.new(/\A\d/)
+      end
+    end
+  end
+
+
+end # of MISParser
+
+class MISTest < Test::Unit::TestCase
+  include ::Yaparc
+
+  def test_digit
+    digit = MISParser::Digit.new
+    assert_instance_of Result::OK, digit.parse("3")
+  end
+
+  def test_uinteger
+    uinteger = MISParser::Digit.new
+    assert_instance_of Result::OK, uinteger.parse("3")
+    assert_instance_of Result::OK, uinteger.parse("123")
+    assert_instance_of Result::OK, uinteger.parse("0123")
+  end
+
+  def test_suffix
+    suffix = MISParser::Suffix.new
+    assert_instance_of Result::OK, suffix.parse("e3")
+    assert_instance_of Result::OK, suffix.parse("E-10")
+    assert_instance_of Result::OK, suffix.parse("e09876")
+  end
+
+  def test_numerical_value
+    numerical_value = MISParser::NumericalValue.new
+    assert_instance_of Result::OK, numerical_value.parse("3")
+    assert_instance_of Result::OK, numerical_value.parse("0.9")
+    assert_instance_of Result::OK, numerical_value.parse(".987")
+    assert_instance_of Result::OK, numerical_value.parse("0987.")
+  end
+
+
+  def test_ureal
+    ureal = MISParser::Ureal.new
+    assert_instance_of Result::OK, ureal.parse("3")
+    assert_instance_of Result::OK, ureal.parse("0.9e10")
+    assert_instance_of Result::OK, ureal.parse(".987E-098")
+  end
+
+  def test_real
+    real = MISParser::Real.new
+    assert_instance_of Result::OK, real.parse("-0.9e10")
+    assert_instance_of Result::OK, real.parse("-.987E-098")
+  end
+
+  def test_unit
+    unit = MISParser::Unit.new
+    assert_instance_of Result::OK, unit.parse("s^-1")
+    assert_instance_of Result::OK, unit.parse("dm^3")
+    assert_instance_of Result::OK, unit.parse("rad^2")
+    assert_instance_of Result::OK, unit.parse("Mg")
+    assert_instance_of Result::OK, unit.parse("mol/s")
+    assert_instance_of Result::OK, unit.parse("cd.sr")
+    assert_instance_of Result::OK, unit.parse("lm/m^2")
+    assert_instance_of Result::OK, unit.parse("m.kg.s^-2")
+    assert_instance_of Result::OK, unit.parse("N/m^2")
+    assert_instance_of Result::OK, unit.parse("N.m")
+    assert_instance_of Result::OK, unit.parse("J/s")
+    assert_instance_of Result::OK, unit.parse("s.A")
+    assert_instance_of Result::OK, unit.parse("W/A")
+    assert_instance_of Result::OK, unit.parse("C/V")
+    assert_instance_of Result::OK, unit.parse("V/A")
+    assert_instance_of Result::OK, unit.parse("A/V")
+    assert_instance_of Result::OK, unit.parse("V.s")
+    assert_instance_of Result::OK, unit.parse("Wb/m^2")
+    assert_instance_of Result::OK, unit.parse("Wb/A")
+    assert_instance_of Result::OK, unit.parse("m^2.s^-2")
+    assert_instance_of Result::OK, unit.parse("m^2")
+    assert_instance_of Result::OK, unit.parse("m^3")
+    assert_instance_of Result::OK, unit.parse("m/s")
+    assert_instance_of Result::OK, unit.parse("m/s^2")
+    assert_instance_of Result::OK, unit.parse("m^-1")
+    assert_instance_of Result::OK, unit.parse("kg/m^3")
+    assert_instance_of Result::OK, unit.parse("m^3/kg")
+    assert_instance_of Result::OK, unit.parse("A/m^2")
+    assert_instance_of Result::OK, unit.parse("mol/m^3")
+    assert_instance_of Result::OK, unit.parse("cd/m^3")
+    assert_instance_of Result::OK, unit.parse("rad/s")
+    assert_instance_of Result::OK, unit.parse("rad/s^2")
+    assert_instance_of Result::OK, unit.parse("Pa.s")
+    assert_instance_of Result::OK, unit.parse("W/m^2")
+    assert_instance_of Result::OK, unit.parse("W/sr")
+    assert_instance_of Result::OK, unit.parse("W/(m^2.sr)")
+    assert_instance_of Result::OK, unit.parse("J/K")
+    assert_instance_of Result::OK, unit.parse("J/(kg.K)")
+    assert_instance_of Result::OK, unit.parse("J/kg")
+    assert_instance_of Result::OK, unit.parse("W/(m.k)")
+    assert_instance_of Result::OK, unit.parse("J/m^3")
+    assert_instance_of Result::OK, unit.parse("C/m^3")
+    assert_instance_of Result::OK, unit.parse("F/m")
+    assert_instance_of Result::OK, unit.parse("H/m")
+    assert_instance_of Result::OK, unit.parse("J/mol")
+    assert_instance_of Result::OK, unit.parse("J/(mol.k)")
+    assert_instance_of Result::OK, unit.parse("C/kg")
+    assert_instance_of Result::OK, unit.parse("r/min")
+    assert_instance_of Result::OK, unit.parse("kat/m^3")
+    assert_instance_of Result::OK, unit.parse("Mib/s")
+    assert_instance_of Result::OK, unit.parse("nV/Hz^(1/2)")
+  end
+
+  def test_quantity_value
+    quantity_value = MISParser::QuantityValue.new
+    assert_instance_of Result::OK, quantity_value.parse("60.s")
+    assert_instance_of Result::OK, quantity_value.parse("60.min")
+    assert_instance_of Result::OK, quantity_value.parse("24.h")
+    assert_instance_of Result::OK, quantity_value.parse("6.283185307179586.rad")
+    assert_instance_of Result::OK, quantity_value.parse("2.777777777777778e-3.r")
+    assert_instance_of Result::OK, quantity_value.parse("8.bit")
+    assert_instance_of Result::OK, quantity_value.parse("1.660538782e-27.kg")
+    assert_instance_of Result::OK, quantity_value.parse("1.602176487e-19.J")
+    assert_instance_of Result::OK, quantity_value.parse("0.1151293.Np")
+  end
+
+end