gloo 7.0.4 → 7.1.1

data/lib/gloo/persist/persist_man.rb

@@ -191,6 +191,25 @@ module Gloo
         return @maps.select { |fs| fs.roots.include?( root ) }
       end
 
+      #
+      # The path of the file an object was loaded from, or nil if it
+      # didn't come from one. Walks up from the object to the first one
+      # a loaded file declares, so an object created at runtime under a
+      # loaded one gets that file. When several files declare it (a
+      # namespace container), the first one loaded wins.
+      #
+      def source_file_of( obj )
+        declared = @maps.map { |fs| [ fs, declared_by( fs ) ] }
+        o = obj
+        while o && !o.root?
+          match = declared.find { |_, owned| owned.key?( o ) }
+          return match.first.pn if match
+
+          o = o.parent
+        end
+        return nil
+      end
+
 
       #
       # Get the full path and name of the file.
@@ -265,6 +284,15 @@ module Gloo
         end
       end
 
+      #
+      # Every heap object fs's SourceDoc declares.
+      #
+      def declared_by( fs )
+        owned = {}.compare_by_identity
+        collect_owned( fs.source_doc&.children, owned )
+        return owned
+      end
+
       #
       # Every heap object declared by some loaded file's SourceDoc
       # other than fs.
@@ -368,7 +396,7 @@ module Gloo
       #
       def warn_if_dirty( fs )
         saver = Gloo::Persist::FileSaver.new( @engine, fs.pn, fs.obj, fs.source_doc )
-        @engine.log.warn "#{RELOAD_DIRTY_WARNING}#{fs.pn}" if saver.dirty?
+        @engine.warn "#{RELOAD_DIRTY_WARNING}#{fs.pn}" if saver.dirty?
       end
 
     end

data/lib/gloo/verbs/break.rb

@@ -51,11 +51,16 @@ module Gloo
         {
           :name => KEYWORD,
           :shortcut => KEYWORD_SHORT,
-          :description => 'Break out of the current script, stop running.',
+          :description => 'Break out of the current script, stop running. ' \
+            'If that script is the do script of a loop (repeat, or any ' \
+            'kind of each), the whole loop ends.',
           :syntax => [ 'break' ],
           :result => 'No more commands are executed in the currently ' \
             'running script. If there are other scripts in the stack, ' \
-            'they will resume normally.',
+            'they will resume normally. In a loop\'s do script, the loop ' \
+            'ends too and runs no more passes; the script that ran the ' \
+            'loop carries on. A break in a script the do script runs ' \
+            '(eg. with run) ends only that script, not the loop.',
           :examples => <<~EXAMPLES.strip
             #
             # Break out of a script.

data/lib/gloo/verbs/context.rb

@@ -16,6 +16,8 @@ module Gloo
       # Run the verb.
       #
       def run
+        return unless take_evaluated_arg
+
         set_context if @tokens.token_count > 1
         show_context
       end
@@ -74,9 +76,12 @@ module Gloo
             "to that path. Use 'context root' to set the context back to " \
             'the root level. When context has been set, the pathname can ' \
             'start from the context container by use of the @. prefix.',
-          :syntax => [ 'context {path.to.new.context}' ],
+          :syntax => [ 'context {path.to.new.context}', 'context ( {expression} )' ],
           :parameters => [
-            '{path.to.new.context} — Optional. The path to the new context when setting the context.'
+            '{path.to.new.context} — Optional. The path to the new context when setting the context.',
+            '( {expression} ) — Instead of a literal path, an expression ' \
+              'in parentheses: it is worked out and its value is used as ' \
+              'the path to the new context.'
           ],
           :result => 'Context is optionally set. It will be set to the ' \
             'new context path when we are changing context. Context is ' \
@@ -100,6 +105,9 @@ module Gloo
                     @ context.sub
                     show @.msg
                     @ root
+
+            # The path can be worked out:
+            > context ( 'context.' 'sub' )
           EXAMPLES
         }
       end

data/lib/gloo/verbs/eval.rb

@@ -30,9 +30,8 @@ module Gloo
       #
       def run
         if @tokens.token_count > 1
-          expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
-          result = expr.evaluate
-          @engine.heap.it.set_to result
+          result, ok = evaluate_expr( @tokens.params )
+          @engine.heap.it.set_to( ok ? result : false )
         else
           @engine.heap.it.set_to true
         end
@@ -61,7 +60,9 @@ module Gloo
             '{expression} — The expression that will be evaluated. The expression is optional. If not provided, eval will result in true.'
           ],
           :result => 'The result of the expression evaluation is put ' \
-            'into it. No other action is performed.',
+            'into it. No other action is performed. If the expression ' \
+            'fails (eg. it names a missing object), the error is ' \
+            'reported and it is false.',
           :examples => <<~EXAMPLES.strip,
             > eval "me"
             > eval "hello " "world"

data/lib/gloo/verbs/exists.rb

@@ -23,6 +23,8 @@ module Gloo
       # Run the verb.
       #
       def run
+        return @engine.heap.it.set_to( false ) unless take_evaluated_arg
+
         if @tokens.token_count == 3
           type = @tokens.second.strip.downcase
           keyword = @tokens.last
@@ -105,7 +107,10 @@ module Gloo
           :description => 'Check to see if a verb or object type has ' \
             'been defined (or loaded), or if an object instance exists ' \
             'in the heap. With no kind, any of the three counts.',
-          :syntax => [ 'exists? |any,object,verb,instance| {keyword}' ],
+          :syntax => [
+            'exists? |any,object,verb,instance| {keyword}',
+            'exists? |any,object,verb,instance| ( {expression} )'
+          ],
           :parameters => [
             "Kind of Keyword — Optional; any is the default. " \
               "any checks for a verb, an object type, or an object instance; " \
@@ -115,7 +120,10 @@ module Gloo
               "instance exists at the pathname represented by keyword. " \
               "`exists? any markdown` is identical to `exists? markdown`.",
             '{keyword} — A verb or object type keyword or keyword shortcut, ' \
-              'or the pathname to an object instance. Must be specified.'
+              'or the pathname to an object instance. Must be specified.',
+            '( {expression} ) — Instead of a literal keyword, an expression ' \
+              'in parentheses: it is worked out and its value is used as ' \
+              'the keyword or pathname.'
           ],
           :result => 'If the verb, object type or instance exists, then ' \
             'true, otherwise false. The result will be in it.',
@@ -142,6 +150,10 @@ module Gloo
 
             \t\texists? instance exists.on_load
             \t\tshow it # true
+
+            \t\t# The keyword can be worked out
+            \t\texists? object ( 'mark' 'down' )
+            \t\tshow it # true
           EXAMPLES
         }
       end

data/lib/gloo/verbs/invoke.rb

@@ -60,7 +60,8 @@ module Gloo
             '{path.to.function} — The function we want to invoke.',
             '{params} — The list of parameters to the function.'
           ],
-          :result => 'The result of the function is put into it. The ' \
+          :result => 'The result of the function is put into it; if ' \
+            'anything goes wrong, it is false. The ' \
             'inline forms (invoke(...), ~>(...)) can be used anywhere ' \
             'an expression is evaluated - show, put ... into, if, ' \
             'unless, eval, and more - and evaluate to the result ' \
@@ -69,13 +70,13 @@ module Gloo
             "#{Gloo::Core::Invoker::NO_TARGET_ERR} — No function reference was given.",
             "Object '{path.to.function}' was not found. — The path doesn't resolve to any object.",
             "#{Gloo::Core::Invoker::NOT_FUNCTION_ERR}{path.to.function} — The path resolves to an object that isn't a function.",
-            "#{Gloo::Core::Invoker::PARAM_COUNT_ERR}{path.to.function} (expected N, got N) — The number of params given doesn't match what the function declares."
+            "#{Gloo::Core::Invoker::PARAM_COUNT_ERR}{path.to.function} (expected N, got N) — The number of params given doesn't match what the function declares.",
+            "Object '{param}' was not found. — A param names an object that doesn't exist. The function isn't run."
           ],
           :notes => 'If the function itself fails during invocation ' \
-            '(its on_invoke script hits an error), it is left ' \
-            'unchanged rather than being set to an unreliable result. ' \
-            'The underlying error is whatever was reported by the ' \
-            'failure inside the function. ' \
+            '(its on_invoke script hits an error), it is false rather ' \
+            'than an unreliable result. The underlying error is ' \
+            'whatever was reported by the failure inside the function. ' \
             'Inline call params are space-separated, same as the ' \
             'standalone verb - each one is evaluated as a single ' \
             'token (a literal or object reference), not a multi-token ' \

data/lib/gloo/verbs/load.rb

@@ -23,6 +23,8 @@ module Gloo
       # Run the verb.
       #
       def run
+        return unless take_evaluated_arg
+
         if @tokens.token_count == 2
           opt = FILE_OPT
           fn = @tokens.second
@@ -109,13 +111,18 @@ module Gloo
           :syntax => [
             'load {file_name}',
             'load ext {my_ext}',
-            'load lib {lib_name}'
+            'load lib {lib_name}',
+            'load [ext|lib] ( {expression} )'
           ],
           :parameters => [
             '{file_name} — Name of the object file that is to be loaded.',
             'reference type — By default, the type is file. File can be ' \
               'specified, but does not need to be. Use ext to load a ' \
-              'User Extension. Use lib to load a Core Library.'
+              'User Extension. Use lib to load a Core Library.',
+            '( {expression} ) — Instead of a literal name, an expression ' \
+              'in parentheses: it is worked out and its value is used as ' \
+              'the file, extension or library name. Wildcards and the ' \
+              '.gloo extension work as they do for a literal name.'
           ],
           :result => 'Objects are loaded into the heap. on_load scripts ' \
             'are run within the loaded objects.',
@@ -132,6 +139,9 @@ module Gloo
             'they merge in the heap. If two loaded files declare the ' \
             'same object with different values, the first one loaded ' \
             "wins and a warning is logged.\n\n" \
+            'A file with no objects in it (empty, comments only, or ' \
+            "only 'load lib' lines) loads nothing and logs a warning " \
+            "naming the file; it isn't an error.\n\n" \
             'A contiguous run of whole-line comments declared ' \
             'immediately above an object (same indent, no blank line ' \
             "in between) becomes that object's doc, captured as the " \
@@ -145,6 +155,10 @@ module Gloo
             > load my/app/*
             > load ~/.my_app/settings.gloo
 
+            # Load a file whose name is worked out
+            > load ( $.gloo_tmp '/scratch.gloo' )
+            > load ( my.file_obj )
+
             # Load a User Extension
             > load ext my_ext
 

data/lib/gloo/verbs/log.rb

@@ -50,11 +50,12 @@ module Gloo
       # Write to the specified logger.
       # 
       def write_to_log
-        expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
-        result = expr.evaluate
+        # A failed expression is still logged as far as it got, but it
+        # is false.
+        result, ok = evaluate_expr( @tokens.params )
         level = log_level_specified( result )
         @engine.log.write result, level
-        @engine.heap.it.set_to result
+        @engine.heap.it.set_to( ok ? result : false )
       end
 
       # 
@@ -106,7 +107,10 @@ module Gloo
               'not specified, the message is written as DEBUG level.'
           ],
           :result => 'The message is written to the log at the ' \
-            'specified level. It will contain the log message.',
+            'specified level. It will contain the log message. If the ' \
+            'expression fails, the error is reported and what was ' \
+            'worked out so far is still logged, but it is false. A ' \
+            'level that can\'t be worked out falls back to debug.',
           :notes => "Use `log clear` from the CLI to clear out both the " \
             "standard log and the error log.\n\n" \
             "> log clear",

data/lib/gloo/verbs/save.rb

@@ -48,9 +48,11 @@ module Gloo
       # Run 'save {obj} to {path}'.
       #
       def run_save_to
+        return unless take_evaluated_arg
+
         name = @tokens.before_token( TO )[ 1 ]
         path = @tokens.after_token( TO )
-        unless path
+        if path.blank?
           @engine.syntax_err MISSING_PATH_ERR
           return
         end
@@ -84,13 +86,17 @@ module Gloo
           :syntax => [
             'save',
             'save {path.to.object}',
-            'save {path.to.object} to {path}'
+            'save {path.to.object} to {path}',
+            'save {path.to.object} to ( {expression} )'
           ],
           :parameters => [
             '{path.to.object} — Name of the object to save.',
             '{path} — Where to save it, relative to the project root ' \
               '(.gloo appended if omitted). Registers the mapping, so ' \
-              'a later bare save includes it.'
+              'a later bare save includes it.',
+            '( {expression} ) — Instead of a literal path, an expression ' \
+              'in parentheses: it is worked out and its value is used as ' \
+              'the path.'
           ],
           :result => 'The file(s) are updated with the latest object ' \
             'state. This is a rewrite, not a regeneration: comments, ' \
@@ -129,6 +135,7 @@ module Gloo
             > save my_obj
             > save my_obj to sub/my_obj
             > save app.core.settings to config/settings
+            > save my_obj to ( $.gloo_tmp '/my_obj' )
           EXAMPLES
         }
       end

data/lib/gloo/verbs/show.rb

@@ -16,10 +16,11 @@ module Gloo
       #
       def run
         if @tokens.token_count > 1
-          expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
-          result = expr.evaluate
+          # A failed expression is still shown as far as it got (a best
+          # guess, and handy when debugging), but it is false.
+          result, ok = evaluate_expr( @tokens.params )
           @engine.log.show get_formatted_string( result )
-          @engine.heap.it.set_to result
+          @engine.heap.it.set_to( ok ? result : false )
         else
           @engine.log.show ''
         end
@@ -46,14 +47,16 @@ module Gloo
       private
 
       #
-      # Get the formatted string.
+      # Get the formatted string: in the color given in the params, if
+      # any. A color that can't be worked out (already reported) shows
+      # the string plain.
       #
       def get_formatted_string( str )
         if @params&.token_count&.positive?
-          expr = Gloo::Expr::Expression.new( @engine, @params.tokens )
-          val = expr.evaluate
-          color = val.to_sym
-          return @engine.platform.get_colorized_string( str, color )
+          val, ok = evaluate_expr( @params.tokens )
+          return str unless ok && val
+
+          return @engine.platform.get_colorized_string( str, val.to_sym )
         end
         return str
       end
@@ -79,11 +82,13 @@ module Gloo
             '{target} — The object that we want to see. The target ' \
               'might be the path to an object, a literal or an ' \
               'expression to be evaluated before being shown.',
-            '{color} — Optional color for the text.'
+            '{color} — Optional color for the text. If the color can\'t be worked out, the error is reported and the text is shown plain.'
           ],
           :result => "The object's value is shown, or the literal, or " \
             'the result of the evaluated expression is shown. It will ' \
-            "contain the object's value.",
+            "contain the object's value. If the expression fails (eg. " \
+            'it names a missing object), the error is reported and ' \
+            'what was worked out so far is still shown, but it is false.',
           :examples => <<~EXAMPLES.strip,
             > show "me"
             > show "hello " "world"

data/test.gloo/ctrl/each.test.gloo

@@ -38,23 +38,37 @@ tests.ctrl.each [can] :
 
 #
 # Each file / each dir over a nested folder tree.
-# The tree is built under /tmp and removed at the end.
+# The tree is built in $.gloo_tmp and removed at the end. It's built
+# and removed with shell commands, so these tests need a Unix shell.
 #
 
 tests.ctrl.each_folder [can] :
 
   count [int] : 0
+  walk_name [string] : /gloo_each_walk
+  walk [string] :
 
   make_tree [system] :
-    command [string] : rm -rf /tmp/gloo_each_walk && mkdir -p /tmp/gloo_each_walk/a/deep /tmp/gloo_each_walk/.obs && touch /tmp/gloo_each_walk/top.md /tmp/gloo_each_walk/notes.txt /tmp/gloo_each_walk/a/x.md /tmp/gloo_each_walk/a/deep/Y.MD /tmp/gloo_each_walk/.obs/o.md
+    command [string] :
     get_output [bool] : false
   remove_tree [system] :
-    command [string] : rm -rf /tmp/gloo_each_walk
+    command [string] :
     get_output [bool] : false
 
+  # The tree lives in the gloo tmp folder ($.gloo_tmp); paths are
+  # quoted in the commands in case that folder has spaces.
+  on_load [script] :
+    put $.gloo_tmp ^.walk_name into ^.walk
+    put "rm -rf '" ^.walk "' && mkdir -p '" ^.walk "/a/deep' '" ^.walk "/.obs' && cd '" ^.walk "' && touch top.md notes.txt a/x.md a/deep/Y.MD .obs/o.md" into ^.make_tree.command
+    put "rm -rf '" ^.walk "'" into ^.remove_tree.command
+    put ^.walk into ^.files.in
+    put ^.walk '/**/' into ^.wild.in
+    put ^.walk into ^.top.in
+    put ^.walk into ^.dirs.in
+
   files [each] :
     file [file] :
-    in [file] : /tmp/gloo_each_walk
+    in [file] :
     ext [string] : md
     recursive [bool] : true
     do [script] :
@@ -63,7 +77,7 @@ tests.ctrl.each_folder [can] :
 
   wild [each] :
     file [file] :
-    in [file] : /tmp/gloo_each_walk/**/
+    in [file] :
     ext [string] : md
     do [script] :
       eval ^^.count + 1
@@ -71,14 +85,14 @@ tests.ctrl.each_folder [can] :
 
   top [each] :
     file [file] :
-    in [file] : /tmp/gloo_each_walk
+    in [file] :
     do [script] :
       eval ^^.count + 1
       put it into ^^.count
 
   dirs [each] :
     dir [file] :
-    in [file] : /tmp/gloo_each_walk
+    in [file] :
     recursive [bool] : true
     do [script] :
       eval ^^.count + 1

data/test.gloo/lang/declaration.test.gloo

@@ -7,7 +7,12 @@ tests.lang.declaration [can] :
   # A fixture deliberately missing the ']' after its type, loaded inside
   # its test so the syntax error it reports belongs to that test.
   # Loading reads the type as 'int' anyway.
-  unclosed_file [file] : /tmp/gloo_declaration_test.gloo
+  unclosed_file [file] :
+
+  # Scratch files live in the gloo tmp folder ($.gloo_tmp).
+  on_load [script] :
+    put $.gloo_tmp '/gloo_declaration_test.gloo' into ^.unclosed_file
+
   unclosed_src [text] : BEGIN
 declaration_fixture [container] :
   unclosed [int : 7
@@ -20,7 +25,7 @@ END
     expect_errors [bool] : true
     on_test [script] :
       tell ^^.unclosed_file to write ( ^^.unclosed_src )
-      load /tmp/gloo_declaration_test.gloo
+      load ( ^^.unclosed_file )
       eval declaration_fixture.unclosed = 7
       assert "expected the value 7"
 

data/test.gloo/lang/exceptions.test.gloo

@@ -23,6 +23,18 @@ tests.lang.exceptions [can] :
     kind [string] :
     location [string] :
 
+  # A scratch file with a mistake in it, for the location of an error in
+  # a loaded file.
+  broken_file [file] :
+  broken_name [string] : /gloo_exceptions_location.gloo
+  broken_src [text] : BEGIN
+broken_location_demo [can] :
+  count [int : 3
+END
+
+  on_load [script] :
+    put $.gloo_tmp ^.broken_name into ^.broken_file
+
   confirm_throw_fires_on_exception [test] :
     description [string] : Confirm throw fires on_exception and populates exception_data, but does not fire on_error.
     expect_errors [bool] : true
@@ -127,3 +139,13 @@ tests.lang.exceptions [can] :
       eval ^^.num = 0
       assert "expected the best guess, 0"
 
+  confirm_error_location_in_a_loaded_file [test] :
+    description [string] : an error in a file a script loads names that file and line, not the script.
+    expect_errors [bool] : true
+    on_test [script] :
+      tell ^^.broken_file to write ( ^^.broken_src )
+      load ( ^^.broken_file )
+      check ^^.error_data.location for ends_with? ( 'gloo_exceptions_location.gloo:2' )
+      assert "expected the location to be the loaded file and line"
+      tell broken_location_demo to unload
+      tell ^^.broken_file to delete

data/test.gloo/lang/gloo_sys.test.gloo

@@ -79,6 +79,18 @@ tests.lang.gloo_sys [can] :
       eval it = ''
       refute "expected gloo_log to not be empty"
 
+  get_gloo_tmp [test] :
+    description [string] : $.gloo_tmp is a folder that exists.
+    f [file] :
+    on_test [script] :
+      eval $.gloo_tmp
+      eval it = ''
+      refute "expected gloo_tmp to not be empty"
+
+      put $.gloo_tmp into ^.f
+      check ^.f for is_dir?
+      assert "expected gloo_tmp to be an existing folder"
+
   get_screen_dims [test] :
     description [string] : Get the screen dimensions.
     i [int] :

data/test.gloo/lang/naming.test.gloo

@@ -16,7 +16,12 @@ tests.lang.naming [can] :
 
   # A fixture with a deliberately nameless object, loaded inside its
   # test so the syntax error it reports belongs to that test.
-  nameless_file [file] : /tmp/gloo_naming_test.gloo
+  nameless_file [file] :
+
+  # Scratch files live in the gloo tmp folder ($.gloo_tmp).
+  on_load [script] :
+    put $.gloo_tmp '/gloo_naming_test.gloo' into ^.nameless_file
+
   nameless_src [text] : BEGIN
 naming_fixture [container] :
   [string] : no name given
@@ -54,7 +59,7 @@ END
     expect_errors [bool] : true
     on_test [script] :
       tell ^^.nameless_file to write ( ^^.nameless_src )
-      load /tmp/gloo_naming_test.gloo
+      load ( ^^.nameless_file )
       eval naming_fixture.unnamed_1 = 'no name given'
       assert "expected the nameless object to be reached as unnamed_1"
 

data/test.gloo/objs/cipher.test.gloo

@@ -41,3 +41,30 @@ tests.objs.cipher [can] :
       tell tests.objs.cipher.b to decrypt
       eval tests.objs.cipher.b.data = ^^.plaintext
       assert "expected the second cipher to decrypt with the shared key"
+
+  # Fixed values, so the results never vary: 'hello' encrypted with key
+  # ('k' x 32) and iv ('i' x 16), and a wrong key ('0' x 32) whose
+  # garbage fails the padding check. (AES-CBC can't always tell a key is
+  # wrong: about 1 wrong key in 256 gives garbage with no error.)
+  fixed_iv [string] : aWlpaWlpaWlpaWlpaWlpaQ==
+  hello_encrypted [string] : aRyXOIIhJzBhh+BthfFstw==
+  wrong_key [string] : MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA=
+  err_fired [bool] : false
+
+  on_error [script] :
+    put true into ^.err_fired
+
+  wrong_key_is_an_error [test] :
+    description [string] : decrypt with a wrong key that fails the padding check reports an error.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      create tests.objs.cipher.w as cipher
+      put ^^.wrong_key into tests.objs.cipher.w.key
+      put ^^.fixed_iv into tests.objs.cipher.w.init_vector
+      put ^^.hello_encrypted into tests.objs.cipher.w.data
+      tell tests.objs.cipher.w to decrypt
+      eval it = false
+      assert "expected it to be false"
+      eval ^^.err_fired = true
+      assert "expected on_error to fire for the wrong key"

data/test.gloo/objs/file.test.gloo

@@ -2,12 +2,17 @@
 # File object tests
 #
 # The file object's value is a path.  These tests write a scratch
-# file under /tmp, exercise it, and delete it at the end.
+# file in $.gloo_tmp, exercise it, and delete it at the end.
 #
 
 tests.objs.file [can] :
 
-  f [file] : /tmp/gloo_file_test.txt
+  f [file] :
+
+  # Scratch files live in the gloo tmp folder ($.gloo_tmp).
+  on_load [script] :
+    put $.gloo_tmp '/gloo_file_test.txt' into ^.f
+
   names [file] : /Users/me/project/report.csv
 
   first [string] : first line
@@ -29,11 +34,22 @@ tests.objs.file [can] :
       refute "expected the file not to be a directory"
 
       tell ^^.f to read ( ^^.back )
+      eval it = true
+      assert "expected read into a destination to put true in it"
       eval ^^.back = 'first line'
       assert "expected read to return what was written"
 
       tell ^^.f to delete
 
+  read_without_a_destination_puts_the_data_in_it [test] :
+    description [string] : read with no destination puts the file's contents in it.
+    on_test [script] :
+      tell ^^.f to write ( ^^.first )
+      tell ^^.f to read
+      eval it = 'first line'
+      assert "expected the file's contents in it"
+      tell ^^.f to delete
+
   append_adds_a_line [test] :
     description [string] : append adds a new line to the file.
     on_test [script] :

data/test.gloo/objs/fixtures/source_dir_fixture.gloo

@@ -0,0 +1,6 @@
+#
+# Fixture for obj.test.gloo: loaded from the folder next to that test
+# file, found with source_dir. Not a test file itself.
+#
+source_dir_fixture [can] :
+  msg [string] : found next door

data/test.gloo/objs/int.test.gloo

@@ -48,10 +48,13 @@ tests.objs.int [can] :
       eval ^^.a <= 100
       assert "expected it to be less than or equal to 100"
           
+      # A random value is only checked for its range: two random values
+      # are equal now and then, so 'not equal' would fail at random.
       tell ^^.a to randomize (10000)
-      tell ^^.b to randomize (10000)
-      eval ^^.a = ^^.b
-      refute "expected them to not be equal"
+      eval ^^.a >= 0
+      assert "expected it to be greater than or equal to 0"
+      eval ^^.a < 10000
+      assert "expected it to be less than 10000"
 
   format_int [test] :
     description [string] : Format an integer

data/test.gloo/objs/json.test.gloo

@@ -43,6 +43,8 @@ tests.objs.json [can] :
     description [string] : parse builds an object tree from the JSON.
     on_test [script] :
       tell ^^.payload to parse ( tests.objs.json.out )
+      eval it = true
+      assert "expected parse to put true in it"
 
       eval tests.objs.json.out.title = 'Brute Force'
       assert "expected parse to set the title"