scratch – Diff between revs 75 and 125

Subversion Repositories:

?pathlinks?

Rev 75 – Details – Blame – Last modification – View Log

Only display areas with differences – Ignore whitespace

 unless YAML?
     YAML = require '../../src/Yaml'
 # Parsing
+#
 describe 'Parsed YAML Collections', ->
     it 'can be simple sequence', ->
         expect YAML.parse """
         - apple
         - banana
         - carrot
         """
         .toEqual ['apple', 'banana', 'carrot']
     it 'can be nested sequences', ->
         expect YAML.parse """
+        -
          - foo
          - bar
          - baz
         """
         .toEqual [['foo', 'bar', 'baz']]
     it 'can be mixed sequences', ->
         expect YAML.parse """
         - apple
+        -
          - foo
          - bar
          - x123
         - banana
         - carrot
         """
         .toEqual ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot']
     it 'can be deeply nested sequences', ->
         expect YAML.parse """
+        -
+         -
           - uno
           - dos
         """
         .toEqual [[['uno', 'dos']]]
     it 'can be simple mapping', ->
         expect YAML.parse """
         foo: whatever
         bar: stuff
         """
         .toEqual foo: 'whatever', bar: 'stuff'
     it 'can be sequence in a mapping', ->
         expect YAML.parse """
         foo: whatever
         bar:
          - uno
          - dos
         """
         .toEqual foo: 'whatever', bar: ['uno', 'dos']
     it 'can be nested mappings', ->
         expect YAML.parse """
         foo: whatever
         bar:
          fruit: apple
          name: steve
          sport: baseball
         """
         .toEqual foo: 'whatever', bar: (fruit: 'apple', name: 'steve', sport: 'baseball')
     it 'can be mixed mapping', ->
         expect YAML.parse """
         foo: whatever
         bar:
+         -
            fruit: apple
            name: steve
            sport: baseball
          - more
+         -
            python: rocks
            perl: papers
            ruby: scissorses
         """
         .toEqual foo: 'whatever', bar: [
             (fruit: 'apple', name: 'steve', sport: 'baseball'),
             'more',
             (python: 'rocks', perl: 'papers', ruby: 'scissorses')
+        ]
     it 'can have mapping-in-sequence shortcut', ->
         expect YAML.parse """
         - work on YAML.py:
            - work on Store
         """
         .toEqual [('work on YAML.py': ['work on Store'])]
     it 'can have unindented sequence-in-mapping shortcut', ->
         expect YAML.parse """
         allow:
         - 'localhost'
         - '%.sourceforge.net'
         - '%.freepan.org'
         """
         .toEqual (allow: ['localhost', '%.sourceforge.net', '%.freepan.org'])
     it 'can merge key', ->
         expect YAML.parse """
         mapping:
           name: Joe
           job: Accountant
           <<:
             age: 38
         """
         .toEqual mapping:
                     name: 'Joe'
                     job: 'Accountant'
                     age: 38
     it 'can ignore trailing empty lines for smallest indent', ->
         expect YAML.parse """ trailing: empty lines\n"""
         .toEqual trailing: 'empty lines'
 describe 'Parsed YAML Inline Collections', ->
     it 'can be simple inline array', ->
         expect YAML.parse """
         ---
         seq: [ a, b, c ]
         """
         .toEqual seq: ['a', 'b', 'c']
     it 'can be simple inline hash', ->
         expect YAML.parse """
         ---
         hash: { name: Steve, foo: bar }
         """
         .toEqual hash: (name: 'Steve', foo: 'bar')
     it 'can be nested inline hash', ->
         expect YAML.parse """
         ---
         hash: { val1: "string", val2: { v2k1: "v2k1v" } }
         """
         .toEqual hash: (val1: 'string', val2: (v2k1: 'v2k1v'))
     it 'can be multi-line inline collections', ->
         expect YAML.parse """
         languages: [ Ruby,
                      Perl,
                      Python ]
         websites: { YAML: yaml.org,
                     Ruby: ruby-lang.org,
                     Python: python.org,
                     Perl: use.perl.org }
         """
         .toEqual (
             languages: ['Ruby', 'Perl', 'Python']
             websites:
                 YAML: 'yaml.org'
                 Ruby: 'ruby-lang.org'
                 Python: 'python.org'
                 Perl: 'use.perl.org'
+        )
 describe 'Parsed YAML Basic Types', ->
     it 'can be strings', ->
         expect YAML.parse """
         ---
         String
         """
         .toEqual 'String'
     it 'can be double-quoted strings with backslashes', ->
         expect YAML.parse """
         str:
             "string with \\\\ inside"
         """
         .toEqual str: 'string with \\ inside'
     it 'can be single-quoted strings with backslashes', ->
         expect YAML.parse """
         str:
             'string with \\\\ inside'
         """
         .toEqual str: 'string with \\\\ inside'
     it 'can be double-quoted strings with line breaks', ->
         expect YAML.parse """
         str:
             "string with \\n inside"
         """
         .toEqual str: 'string with \n inside'
     it 'can be single-quoted strings with escaped line breaks', ->
         expect YAML.parse """
         str:
             'string with \\n inside'
         """
         .toEqual str: 'string with \\n inside'
     it 'can be double-quoted strings with line breaks and backslashes', ->
         expect YAML.parse """
         str:
             "string with \\n inside and \\\\ also"
         """
         .toEqual str: 'string with \n inside and \\ also'
     it 'can be single-quoted strings with line breaks and backslashes', ->
         expect YAML.parse """
         str:
             'string with \\n inside and \\\\ also'
         """
         .toEqual str: 'string with \\n inside and \\\\ also'
     it 'can have string characters in sequences', ->
         expect YAML.parse """
         - What's Yaml?
         - It's for writing data structures in plain text.
         - And?
         - And what? That's not good enough for you?
         - No, I mean, "And what about Yaml?"
         - Oh, oh yeah. Uh.. Yaml for JavaScript.
         """
         .toEqual [
             "What's Yaml?",
             "It's for writing data structures in plain text.",
             "And?",
             "And what? That's not good enough for you?",
             "No, I mean, \"And what about Yaml?\"",
             "Oh, oh yeah. Uh.. Yaml for JavaScript."
+        ]
     it 'can have indicators in strings', ->
         expect YAML.parse """
         the colon followed by space is an indicator: but is a string:right here
         same for the pound sign: here we have it#in a string
         the comma can, honestly, be used in most cases: [ but not in, inline collections ]
         """
         .toEqual (
             'the colon followed by space is an indicator': 'but is a string:right here',
             'same for the pound sign': 'here we have it#in a string',
             'the comma can, honestly, be used in most cases': ['but not in', 'inline collections']
+        )
     it 'can force strings', ->
         expect YAML.parse """
         date string: !str 2001-08-01
         number string: !str 192
         date string 2: !!str 2001-08-01
         number string 2: !!str 192
         """
         .toEqual (
             'date string': '2001-08-01',
             'number string': '192' ,
             'date string 2': '2001-08-01',
             'number string 2': '192'
+        )
     it 'can be single-quoted strings', ->
         expect YAML.parse """
         all my favorite symbols: '#:!/%.)'
         a few i hate: '&(*'
         why do i hate them?: 'it''s very hard to explain'
         """
         .toEqual (
             'all my favorite symbols': '#:!/%.)',
             'a few i hate': '&(*',
             'why do i hate them?': 'it\'s very hard to explain'
+        )
     it 'can be double-quoted strings', ->
         expect YAML.parse """
         i know where i want my line breaks: "one here\\nand another here\\n"
         """
         .toEqual (
             'i know where i want my line breaks': "one here\nand another here\n"
+        )
     it 'can be null', ->
         expect YAML.parse """
         name: Mr. Show
         hosted by: Bob and David
         date of next season: ~
         """
         .toEqual (
             'name': 'Mr. Show'
             'hosted by': 'Bob and David'
             'date of next season': null
+        )
     it 'can be boolean', ->
         expect YAML.parse """
         Is Gus a Liar?: true
         Do I rely on Gus for Sustenance?: false
         """
         .toEqual (
             'Is Gus a Liar?': true
             'Do I rely on Gus for Sustenance?': false
+        )
     it 'can be integers', ->
         expect YAML.parse """
         zero: 0
         simple: 12
         one-thousand: 1,000
         negative one-thousand: -1,000
         """
         .toEqual (
             'zero': 0
             'simple': 12
             'one-thousand': 1000
             'negative one-thousand': -1000
+        )
     it 'can be integers as map keys', ->
         expect YAML.parse """
 : one
 : two
 : three
         """
         .toEqual (
 : 'one'
 : 'two'
 : 'three'
+        )
     it 'can be floats', ->
         expect YAML.parse """
         a simple float: 2.00
         larger float: 1,000.09
         scientific notation: 1.00009e+3
         """
         .toEqual (
             'a simple float': 2.0
             'larger float': 1000.09
             'scientific notation': 1000.09
+        )
     it 'can be time', ->
         iso8601Date = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
         iso8601Date.setTime iso8601Date.getTime() - 5 * 3600 * 1000
         spaceSeparatedDate = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
-        spaceSeparatedDate.setTime spaceSeparatedDate.getTime() - 5 * 3600 * 1000
+        spaceSeparatedDate.setTime spaceSeparatedDate.getTime() + 5 * 3600 * 1000
         withDatesToTime = (input) ->
             res = {}
             for key, val of input
-                res[key] = Math.round(val.getTime() / 1000) * 1000
+                res[key] = val.getTime()
             return res
         expect withDatesToTime(YAML.parse """
-            iso8601: 2001-12-14t21:59:43.10-05:00
+            iso8601: 2001-12-14t21:59:43.010+05:00
-            space seperated: 2001-12-14 21:59:43.10 -05:00
+            space separated: 2001-12-14 21:59:43.010 -05:00
         """)
         .toEqual withDatesToTime (
             'iso8601': iso8601Date
-            'space seperated': spaceSeparatedDate
+            'space separated': spaceSeparatedDate
+        )
     it 'can be date', ->
         aDate = new Date Date.UTC(1976, 7-1, 31, 0, 0, 0, 0)
         withDatesToTime = (input) ->
             return input
             res = {}
             for key, val of input
-                res[key] = Math.round(val.getTime() / 1000) * 1000
+                res[key] = val.getTime()
             return res
         expect withDatesToTime(YAML.parse """
             date: 1976-07-31
         """)
         .toEqual withDatesToTime (
             'date': aDate
+        )
 describe 'Parsed YAML Blocks', ->
     it 'can be single ending newline', ->
         expect YAML.parse """
         ---
         this: |
             Foo
             Bar
         """
         .toEqual 'this': "Foo\nBar\n"
     it 'can be single ending newline with \'+\' indicator', ->
         expect YAML.parse """
         normal: |
           extra new lines not kept
         preserving: |+
           extra new lines are kept
         dummy: value
         """
         .toEqual (
             'normal': "extra new lines not kept\n"
             'preserving': "extra new lines are kept\n\n\n"
             'dummy': 'value'
+        )
     it 'can be multi-line block handling trailing newlines in function of \'+\', \'-\' indicators', ->
         expect YAML.parse """
         clipped: |
             This has one newline.
         same as "clipped" above: "This has one newline.\\n"
         stripped: |-
             This has no newline.
         same as "stripped" above: "This has no newline."
         kept: |+
             This has four newlines.
         same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
         """
         .toEqual (
             'clipped': "This has one newline.\n"
             'same as "clipped" above': "This has one newline.\n"
             'stripped':'This has no newline.'
             'same as "stripped" above': 'This has no newline.'
             'kept': "This has four newlines.\n\n\n\n"
             'same as "kept" above': "This has four newlines.\n\n\n\n"
+        )
     it 'can be folded block in a sequence', ->
         expect YAML.parse """
         ---
         - apple
         - banana
         - >
             can't you see
             the beauty of yaml?
             hmm
         - dog
         """
         .toEqual [
             'apple',
             'banana',
             "can't you see the beauty of yaml? hmm\n",
             'dog'
+        ]
     it 'can be folded block as a mapping value', ->
         expect YAML.parse """
         ---
         quote: >
             Mark McGwire's
             year was crippled
             by a knee injury.
         source: espn
         """
         .toEqual (
             'quote': "Mark McGwire's year was crippled by a knee injury.\n"
             'source': 'espn'
+        )
     it 'can be folded block handling trailing newlines in function of \'+\', \'-\' indicators', ->
         expect YAML.parse """
         clipped: >
             This has one newline.
         same as "clipped" above: "This has one newline.\\n"
         stripped: >-
             This has no newline.
         same as "stripped" above: "This has no newline."
         kept: >+
             This has four newlines.
         same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
         """
         .toEqual (
             'clipped': "This has one newline.\n"
             'same as "clipped" above': "This has one newline.\n"
             'stripped': 'This has no newline.'
             'same as "stripped" above': 'This has no newline.'
             'kept': "This has four newlines.\n\n\n\n"
             'same as "kept" above': "This has four newlines.\n\n\n\n"
+        )
     it 'can be the whole document as intented block', ->
         expect YAML.parse """
         ---
           foo: "bar"
           baz:
             - "qux"
             - "quxx"
           corge: null
         """
         .toEqual (
             'foo': "bar"
             'baz': ['qux', 'quxx']
             'corge': null
+        )
 describe 'Parsed YAML Comments', ->
     it 'can begin the document', ->
         expect YAML.parse """
         # This is a comment
         hello: world
         """
         .toEqual (
             hello: 'world'
+        )
     it 'can be less indented in mapping', ->
         expect YAML.parse """
         parts:
             a: 'b'
             # normally indented comment
             c: 'd'
         # less indented comment
             e: 'f'
         """
         .toEqual (
             parts: {a: 'b', c: 'd', e: 'f'}
+        )
     it 'can be less indented in sequence', ->
         expect YAML.parse """
         list-header:
           - item1
         #  - item2
           - item3
           # - item4
         """
         .toEqual (
             'list-header': ['item1', 'item3']
+        )
     it 'can finish a line', ->
         expect YAML.parse """
         hello: world # This is a comment
         """
         .toEqual (
             hello: 'world'
+        )
     it 'can end the document', ->
         expect YAML.parse """
         hello: world
         # This is a comment
         """
         .toEqual (
             hello: 'world'
+        )
 describe 'Parsed YAML Aliases and Anchors', ->
     it 'can be simple alias', ->
         expect YAML.parse """
         - &showell Steve
         - Clark
         - Brian
         - Oren
         - *showell
         """
         .toEqual ['Steve', 'Clark', 'Brian', 'Oren', 'Steve']
     it 'can be alias of a mapping', ->
         expect YAML.parse """
         - &hello
             Meat: pork
             Starch: potato
         - banana
         - *hello
         """
         .toEqual [
             Meat: 'pork', Starch: 'potato'
+        ,
             'banana'
+        ,
             Meat: 'pork', Starch: 'potato'
+        ]
 describe 'Parsed YAML Documents', ->
     it 'can have YAML header', ->
         expect YAML.parse """
         --- %YAML:1.0
         foo: 1
         bar: 2
         """
         .toEqual (
             foo: 1
             bar: 2
+        )
     it 'can have leading document separator', ->
         expect YAML.parse """
         ---
         - foo: 1
           bar: 2
         """
         .toEqual [(
             foo: 1
             bar: 2
         )]
     it 'can have multiple document separators in block', ->
         expect YAML.parse """
         foo: |
             ---
             foo: bar
             ---
             yo: baz
         bar: |
             fooness
         """
         .toEqual (
            foo: "---\nfoo: bar\n---\nyo: baz\n"
            bar: "fooness\n"
+        )
 # Dumping
+#
 describe 'Dumped YAML Collections', ->
     it 'can be simple sequence', ->
         expect YAML.parse """
         - apple
         - banana
         - carrot
         """
         .toEqual YAML.parse YAML.dump ['apple', 'banana', 'carrot']
     it 'can be nested sequences', ->
         expect YAML.parse """
+        -
          - foo
          - bar
          - baz
         """
         .toEqual YAML.parse YAML.dump [['foo', 'bar', 'baz']]
     it 'can be mixed sequences', ->
         expect YAML.parse """
         - apple
+        -
          - foo
          - bar
          - x123
         - banana
         - carrot
         """
         .toEqual YAML.parse YAML.dump ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot']
     it 'can be deeply nested sequences', ->
         expect YAML.parse """
+        -
+         -
           - uno
           - dos
         """
         .toEqual YAML.parse YAML.dump [[['uno', 'dos']]]
     it 'can be simple mapping', ->
         expect YAML.parse """
         foo: whatever
         bar: stuff
         """
         .toEqual YAML.parse YAML.dump foo: 'whatever', bar: 'stuff'
     it 'can be sequence in a mapping', ->
         expect YAML.parse """
         foo: whatever
         bar:
          - uno
          - dos
         """
         .toEqual YAML.parse YAML.dump foo: 'whatever', bar: ['uno', 'dos']
     it 'can be nested mappings', ->
         expect YAML.parse """
         foo: whatever
         bar:
          fruit: apple
          name: steve
          sport: baseball
         """
         .toEqual YAML.parse YAML.dump foo: 'whatever', bar: (fruit: 'apple', name: 'steve', sport: 'baseball')
     it 'can be mixed mapping', ->
         expect YAML.parse """
         foo: whatever
         bar:
+         -
            fruit: apple
            name: steve
            sport: baseball
          - more
+         -
            python: rocks
            perl: papers
            ruby: scissorses
         """
         .toEqual YAML.parse YAML.dump foo: 'whatever', bar: [
             (fruit: 'apple', name: 'steve', sport: 'baseball'),
             'more',
             (python: 'rocks', perl: 'papers', ruby: 'scissorses')
+        ]
     it 'can have mapping-in-sequence shortcut', ->
         expect YAML.parse """
         - work on YAML.py:
            - work on Store
         """
         .toEqual YAML.parse YAML.dump [('work on YAML.py': ['work on Store'])]
     it 'can have unindented sequence-in-mapping shortcut', ->
         expect YAML.parse """
         allow:
         - 'localhost'
         - '%.sourceforge.net'
         - '%.freepan.org'
         """
         .toEqual YAML.parse YAML.dump (allow: ['localhost', '%.sourceforge.net', '%.freepan.org'])
     it 'can merge key', ->
         expect YAML.parse """
         mapping:
           name: Joe
           job: Accountant
           <<:
             age: 38
         """
         .toEqual YAML.parse YAML.dump mapping:
                     name: 'Joe'
                     job: 'Accountant'
                     age: 38
 describe 'Dumped YAML Inline Collections', ->
     it 'can be simple inline array', ->
         expect YAML.parse """
         ---
         seq: [ a, b, c ]
         """
         .toEqual YAML.parse YAML.dump seq: ['a', 'b', 'c']
     it 'can be simple inline hash', ->
         expect YAML.parse """
         ---
         hash: { name: Steve, foo: bar }
         """
         .toEqual YAML.parse YAML.dump hash: (name: 'Steve', foo: 'bar')
     it 'can be multi-line inline collections', ->
         expect YAML.parse """
         languages: [ Ruby,
                      Perl,
                      Python ]
         websites: { YAML: yaml.org,
                     Ruby: ruby-lang.org,
                     Python: python.org,
                     Perl: use.perl.org }
         """
         .toEqual YAML.parse YAML.dump (
             languages: ['Ruby', 'Perl', 'Python']
             websites:
                 YAML: 'yaml.org'
                 Ruby: 'ruby-lang.org'
                 Python: 'python.org'
                 Perl: 'use.perl.org'
+        )
     it 'can be dumped empty sequences in mappings', ->
         expect YAML.parse(YAML.dump({key:[]}))
         .toEqual({key:[]})
+    it 'can be dumpted empty inline collections', ->
         expect YAML.parse(YAML.dump({key:{}}))
         .toEqual({key:{}})
 describe 'Dumped YAML Basic Types', ->
     it 'can be strings', ->
         expect YAML.parse """
         ---
         String
         """
         .toEqual YAML.parse YAML.dump 'String'
     it 'can be double-quoted strings with backslashes', ->
         expect YAML.parse """
         str:
             "string with \\\\ inside"
         """
         .toEqual YAML.parse YAML.dump str: 'string with \\ inside'
     it 'can be single-quoted strings with backslashes', ->
         expect YAML.parse """
         str:
             'string with \\\\ inside'
         """
         .toEqual YAML.parse YAML.dump str: 'string with \\\\ inside'
     it 'can be double-quoted strings with line breaks', ->
         expect YAML.parse """
         str:
             "string with \\n inside"
         """
         .toEqual YAML.parse YAML.dump str: 'string with \n inside'
     it 'can be double-quoted strings with line breaks and backslashes', ->
         expect YAML.parse """
         str:
             "string with \\n inside and \\\\ also"
         """
         .toEqual YAML.parse YAML.dump str: 'string with \n inside and \\ also'
     it 'can be single-quoted strings with line breaks and backslashes', ->
         expect YAML.parse """
         str:
             'string with \\n inside and \\\\ also'
         """
         .toEqual YAML.parse YAML.dump str: 'string with \\n inside and \\\\ also'
     it 'can be single-quoted strings with escaped line breaks', ->
         expect YAML.parse """
         str:
             'string with \\n inside'
         """
         .toEqual YAML.parse YAML.dump str: 'string with \\n inside'
     it 'can have string characters in sequences', ->
         expect YAML.parse """
         - What's Yaml?
         - It's for writing data structures in plain text.
         - And?
         - And what? That's not good enough for you?
         - No, I mean, "And what about Yaml?"
         - Oh, oh yeah. Uh.. Yaml for JavaScript.
         """
         .toEqual YAML.parse YAML.dump [
             "What's Yaml?",
             "It's for writing data structures in plain text.",
             "And?",
             "And what? That's not good enough for you?",
             "No, I mean, \"And what about Yaml?\"",
             "Oh, oh yeah. Uh.. Yaml for JavaScript."
+        ]
     it 'can have indicators in strings', ->
         expect YAML.parse """
         the colon followed by space is an indicator: but is a string:right here
         same for the pound sign: here we have it#in a string
         the comma can, honestly, be used in most cases: [ but not in, inline collections ]
         """
         .toEqual YAML.parse YAML.dump (
             'the colon followed by space is an indicator': 'but is a string:right here',
             'same for the pound sign': 'here we have it#in a string',
             'the comma can, honestly, be used in most cases': ['but not in', 'inline collections']
+        )
     it 'can force strings', ->
         expect YAML.parse """
         date string: !str 2001-08-01
         number string: !str 192
         date string 2: !!str 2001-08-01
         number string 2: !!str 192
         """
         .toEqual YAML.parse YAML.dump (
             'date string': '2001-08-01',
             'number string': '192' ,
             'date string 2': '2001-08-01',
             'number string 2': '192'
+        )
     it 'can be single-quoted strings', ->
         expect YAML.parse """
         all my favorite symbols: '#:!/%.)'
         a few i hate: '&(*'
         why do i hate them?: 'it''s very hard to explain'
         """
         .toEqual YAML.parse YAML.dump (
             'all my favorite symbols': '#:!/%.)',
             'a few i hate': '&(*',
             'why do i hate them?': 'it\'s very hard to explain'
+        )
     it 'can be double-quoted strings', ->
         expect YAML.parse """
         i know where i want my line breaks: "one here\\nand another here\\n"
         """
         .toEqual YAML.parse YAML.dump (
             'i know where i want my line breaks': "one here\nand another here\n"
+        )
     it 'can be null', ->
         expect YAML.parse """
         name: Mr. Show
         hosted by: Bob and David
         date of next season: ~
         """
         .toEqual YAML.parse YAML.dump (
             'name': 'Mr. Show'
             'hosted by': 'Bob and David'
             'date of next season': null
+        )
     it 'can be boolean', ->
         expect YAML.parse """
         Is Gus a Liar?: true
         Do I rely on Gus for Sustenance?: false
         """
         .toEqual YAML.parse YAML.dump (
             'Is Gus a Liar?': true
             'Do I rely on Gus for Sustenance?': false
+        )
     it 'can be integers', ->
         expect YAML.parse """
         zero: 0
         simple: 12
         one-thousand: 1,000
         negative one-thousand: -1,000
         """
         .toEqual YAML.parse YAML.dump (
             'zero': 0
             'simple': 12
             'one-thousand': 1000
             'negative one-thousand': -1000
+        )
     it 'can be integers as map keys', ->
         expect YAML.parse """
 : one
 : two
 : three
         """
         .toEqual YAML.parse YAML.dump (
 : 'one'
 : 'two'
 : 'three'
+        )
     it 'can be floats', ->
         expect YAML.parse """
         a simple float: 2.00
         larger float: 1,000.09
         scientific notation: 1.00009e+3
         """
         .toEqual YAML.parse YAML.dump (
             'a simple float': 2.0
             'larger float': 1000.09
             'scientific notation': 1000.09
+        )
     it 'can be time', ->
         iso8601Date = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
-        iso8601Date.setTime iso8601Date.getTime() - 5 * 3600 * 1000
+        iso8601Date.setTime iso8601Date.getTime() + 5 * 3600 * 1000
         spaceSeparatedDate = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
         spaceSeparatedDate.setTime spaceSeparatedDate.getTime() - 5 * 3600 * 1000
         withDatesToTime = (input) ->
             res = {}
             for key, val of input
-                res[key] = Math.round(val.getTime() / 1000) * 1000
+                res[key] = val.getTime()
             return res
         expect withDatesToTime(YAML.parse """
-            iso8601: 2001-12-14t21:59:43.10-05:00
+            iso8601: 2001-12-14t21:59:43.010-05:00
-            space seperated: 2001-12-14 21:59:43.10 -05:00
+            space separated: 2001-12-14 21:59:43.010 +05:00
         """)
         .toEqual YAML.parse YAML.dump withDatesToTime (
             'iso8601': iso8601Date
-            'space seperated': spaceSeparatedDate
+            'space separated': spaceSeparatedDate
+        )
     it 'can be date', ->
         aDate = new Date Date.UTC(1976, 7-1, 31, 0, 0, 0, 0)
         withDatesToTime = (input) ->
             return input
             res = {}
             for key, val of input
-                res[key] = Math.round(val.getTime() / 1000) * 1000
+                res[key] = val.getTime()
             return res
         expect withDatesToTime(YAML.parse """
             date: 1976-07-31
         """)
         .toEqual YAML.parse YAML.dump withDatesToTime (
             'date': aDate
+        )
 describe 'Dumped YAML Blocks', ->
     it 'can be single ending newline', ->
         expect YAML.parse """
         ---
         this: |
             Foo
             Bar
         """
         .toEqual YAML.parse YAML.dump 'this': "Foo\nBar\n"
     it 'can be single ending newline with \'+\' indicator', ->
         expect YAML.parse """
         normal: |
           extra new lines not kept
         preserving: |+
           extra new lines are kept
         dummy: value
         """
         .toEqual YAML.parse YAML.dump (
             'normal': "extra new lines not kept\n"
             'preserving': "extra new lines are kept\n\n\n"
             'dummy': 'value'
+        )
     it 'can be multi-line block handling trailing newlines in function of \'+\', \'-\' indicators', ->
         expect YAML.parse """
         clipped: |
             This has one newline.
         same as "clipped" above: "This has one newline.\\n"
         stripped: |-
             This has no newline.
         same as "stripped" above: "This has no newline."
         kept: |+
             This has four newlines.
         same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
         """
         .toEqual YAML.parse YAML.dump (
             'clipped': "This has one newline.\n"
             'same as "clipped" above': "This has one newline.\n"
             'stripped':'This has no newline.'
             'same as "stripped" above': 'This has no newline.'
             'kept': "This has four newlines.\n\n\n\n"
             'same as "kept" above': "This has four newlines.\n\n\n\n"
+        )
     it 'can be folded block in a sequence', ->
         expect YAML.parse """
         ---
         - apple
         - banana
         - >
             can't you see
             the beauty of yaml?
             hmm
         - dog
         """
         .toEqual YAML.parse YAML.dump [
             'apple',
             'banana',
             "can't you see the beauty of yaml? hmm\n",
             'dog'
+        ]
     it 'can be folded block as a mapping value', ->
         expect YAML.parse """
         ---
         quote: >
             Mark McGwire's
             year was crippled
             by a knee injury.
         source: espn
         """
         .toEqual YAML.parse YAML.dump (
             'quote': "Mark McGwire's year was crippled by a knee injury.\n"
             'source': 'espn'
+        )
     it 'can be folded block handling trailing newlines in function of \'+\', \'-\' indicators', ->
         expect YAML.parse """
         clipped: >
             This has one newline.
         same as "clipped" above: "This has one newline.\\n"
         stripped: >-
             This has no newline.
         same as "stripped" above: "This has no newline."
         kept: >+
             This has four newlines.
         same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
         """
         .toEqual YAML.parse YAML.dump (
             'clipped': "This has one newline.\n"
             'same as "clipped" above': "This has one newline.\n"
             'stripped': 'This has no newline.'
             'same as "stripped" above': 'This has no newline.'
             'kept': "This has four newlines.\n\n\n\n"
             'same as "kept" above': "This has four newlines.\n\n\n\n"
+        )
 describe 'Dumped YAML Comments', ->
     it 'can begin the document', ->
         expect YAML.parse """
         # This is a comment
         hello: world
         """
         .toEqual YAML.parse YAML.dump (
             hello: 'world'
+        )
     it 'can finish a line', ->
         expect YAML.parse """
         hello: world # This is a comment
         """
         .toEqual YAML.parse YAML.dump (
             hello: 'world'
+        )
     it 'can end the document', ->
         expect YAML.parse """
         hello: world
         # This is a comment
         """
         .toEqual YAML.parse YAML.dump (
             hello: 'world'
+        )
 describe 'Dumped YAML Aliases and Anchors', ->
     it 'can be simple alias', ->
         expect YAML.parse """
         - &showell Steve
         - Clark
         - Brian
         - Oren
         - *showell
         """
         .toEqual YAML.parse YAML.dump ['Steve', 'Clark', 'Brian', 'Oren', 'Steve']
     it 'can be alias of a mapping', ->
         expect YAML.parse """
         - &hello
             Meat: pork
             Starch: potato
         - banana
         - *hello
         """
         .toEqual YAML.parse YAML.dump [
             Meat: 'pork', Starch: 'potato'
+        ,
             'banana'
+        ,
             Meat: 'pork', Starch: 'potato'
+        ]
 describe 'Dumped YAML Documents', ->
     it 'can have YAML header', ->
         expect YAML.parse """
         --- %YAML:1.0
         foo: 1
         bar: 2
         """
         .toEqual YAML.parse YAML.dump (
             foo: 1
             bar: 2
+        )
     it 'can have leading document separator', ->
         expect YAML.parse """
         ---
         - foo: 1
           bar: 2
         """
         .toEqual YAML.parse YAML.dump [(
             foo: 1
             bar: 2
         )]
     it 'can have multiple document separators in block', ->
         expect YAML.parse """
         foo: |
             ---
             foo: bar
             ---
             yo: baz
         bar: |
             fooness
         """
         .toEqual YAML.parse YAML.dump (
            foo: "---\nfoo: bar\n---\nyo: baz\n"
            bar: "fooness\n"
+        )
 # Loading
 # (disable test when running locally from file)
+#
 url = document?.location?.href
 if not(url?) or url.indexOf('file://') is -1
     examplePath = 'spec/example.yml'
     if __dirname?
         examplePath = __dirname+'/example.yml'
     describe 'YAML loading', ->
         it 'can be done synchronously', ->
             expect(YAML.load(examplePath)).toEqual (
                 this: 'is'
                 a: ['YAML', 'example']
+            )
         it 'can be done asynchronously', (done) ->
             YAML.load examplePath, (result) ->
                 expect(result).toEqual (
                     this: 'is'
                     a: ['YAML', 'example']
+                )
                 done()