gloo 7.1 → 7.1.2

data/lib/gloo/persist/disc_mech.rb

@@ -28,22 +28,30 @@ module Gloo
       end
 
       #
-      # Get all the gloo files in the folder (partial path).
+      # Get all the gloo files in the folder (partial path). The folder
+      # can end with the start of a file name, as a prefix (folder/a).
       #
       def get_all_files_in( folder )
-        pns = []
-        dir = File.join( @engine.settings.project_path, folder )
+        dir = folder_for_files( folder )
+        return Dir.glob( "#{dir}*.gloo" )
+      end
 
-        unless Dir.exist?( dir )
-          @log.debug "Folder does not exist in project: #{folder}"
-          dir = File.join( @engine.settings.user_root, folder )
-          @log.debug "Looking in gloo home? found == #{Dir.exist?( dir )}"
-        end
+      #
+      # Where to look for a folder of files: an absolute or ~ folder as
+      # given (~ expanded), anything else in the project folder, or if it
+      # isn't there, in the gloo home.
+      #
+      def folder_for_files( folder )
+        return folder.sub( '~', Dir.home ) if folder.start_with?( '~' )
+        return folder if File.absolute_path?( folder )
 
-        Dir.glob( "#{dir}*.gloo" ).each do |f|
-          pns << f
-        end
-        return pns
+        dir = File.join( @engine.settings.project_path, folder )
+        return dir if Dir.exist?( dir )
+
+        @log.debug "Folder does not exist in project: #{folder}"
+        dir = File.join( @engine.settings.user_root, folder )
+        @log.debug "Looking in gloo home? found == #{Dir.exist?( dir )}"
+        return dir
       end
 
       # 
@@ -65,23 +73,33 @@ module Gloo
         return true
       end
 
-      # 
-      # Expand a single file path.
-      # 
+      #
+      # Expand a single file path. The .gloo extension is optional: it's
+      # added when the name doesn't end with it, for a full or ~ path
+      # and for a name in the project or gloo home.
+      #
       def expand( name )
-        # Try full path
+        # Try the name as given: a full path, or relative to the working
+        # folder (eg. gloo hello_world.gloo).
         ext_path = File.expand_path( name )
         return [ ext_path ] if self.valid?( ext_path )
 
-        # Try in user root, projects
-        full_name = "#{name}#{file_ext}"
+        full_name = name.end_with?( file_ext ) ? name : "#{name}#{file_ext}"
+
+        # A full or ~ path without the extension.
+        if name.start_with?( '~' ) || File.absolute_path?( name )
+          ext_path = File.expand_path( full_name )
+          return [ ext_path ] if self.valid?( ext_path )
+        end
+
+        # Try in projects
         pn = File.join( @engine.settings.project_path, full_name )
         return [ pn ] if self.valid?( pn )
-        
+
         # Try in user root
         pn = File.join( @engine.settings.user_root, full_name )
         return [ pn ] if self.valid?( pn )
-        
+
         return nil
       end
 

data/lib/gloo/persist/file_loader.rb

@@ -53,7 +53,7 @@ module Gloo
         @trivia = Gloo::Persist::TriviaBuffer.new
         @body = Gloo::Persist::ScriptBodyCollector.new
         @shorthand = Gloo::Persist::ShorthandExpander.new( engine )
-        @ledger = Gloo::Persist::DeclarationLedger.new( engine, pn )
+        @ledger = Gloo::Persist::DeclarationLedger.new( engine )
         @in_block = false
         @block_value = ''
         @body_started = false

data/lib/gloo/persist/persist_man.rb

@@ -396,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/create.rb

@@ -111,7 +111,9 @@ module Gloo
             'value. Both type and value are optional when creating an object.',
           :syntax => [ 'create {new.object.path} as {type} : {value}' ],
           :parameters => [
-            '{new.object.path} — The path and name of the new object.',
+            '{new.object.path} — The path and name of the new object. ' \
+              'Like any path, it can start from the root, from here in ' \
+              'a script (^.box.new, ^^.new), or from the context (@.new).',
             '{type} — The type of the new object. Optional; if not provided the object will be untyped.',
             "{value} — The initial value for the new object. Optional; if not provided the object will have the default value for the type."
           ],
@@ -123,7 +125,7 @@ module Gloo
             "to the existing object's current value.",
           :errors => [
             "#{NO_NAME_ERR} — The name of the object was not specified and the object cannot be created.",
-            "Could not create '{path}': Object '{parent.path}' was not found. — The parent container named in the path does not exist. The path is root-relative and every container above the new object must already exist. Nothing is created, and it is false.",
+            "Could not create '{path}': Object '{parent.path}' was not found. — The parent container named in the path does not exist. Every container above the new object must already exist. Nothing is created, and it is false.",
             "#{format( BAD_NAME_ERR, '{name}' )} — The name has parentheses or quotes, or there are extra words between the name and as / : — create takes a name as written. Nothing is created, and it is false."
           ],
           :examples => <<~EXAMPLES.strip

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/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

@@ -115,7 +115,12 @@ module Gloo
             'load [ext|lib] ( {expression} )'
           ],
           :parameters => [
-            '{file_name} — Name of the object file that is to be loaded.',
+            '{file_name} — Name of the object file that is to be loaded: ' \
+              'relative to the project, a full path, or starting with ~. ' \
+              'The .gloo extension is optional. ' \
+              'End it with * to load every .gloo file in a folder (a ' \
+              'folder in the project, a full path, or one starting with ' \
+              '~); anything before the * is the start of the file names.',
             '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.',
@@ -154,6 +159,7 @@ module Gloo
             > load my/project/file
             > load my/app/*
             > load ~/.my_app/settings.gloo
+            > load ~/.my_app/plugins/*
 
             # Load a file whose name is worked out
             > load ( $.gloo_tmp '/scratch.gloo' )

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/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/lib/gloo.rb

@@ -9,13 +9,27 @@ path = File.dirname( File.absolute_path( __FILE__ ) )
 require File.join( path, 'dependencies.rb' )
 
 module Gloo
-  def self.run
-    params = []
-    ( params << '--cli' ) if ARGV.count.zero?
 
+  #
+  # Run gloo as the command, with the command line's arguments.
+  # This is the only place that reads ARGV; an engine created
+  # in code uses only the params it's given.
+  #
+  def self.run( argv = ARGV )
     platform = Gloo::App::Platform.new
     context = Gloo::App::EngineContext.new(
-      params, platform, Gloo::App::Log, nil )
+      params_for( argv ), platform, Gloo::App::Log, nil )
     Gloo::App::Engine.new( context ).start
   end
+
+  #
+  # Get the engine params for the given command line arguments.
+  # With no arguments, gloo runs in CLI mode.
+  #
+  def self.params_for( argv )
+    params = argv.dup
+    ( params << '--cli' ) if params.empty?
+    return params
+  end
+
 end

data/lib/run.rb

@@ -5,14 +5,8 @@
 # From the /lib/ directory:  ruby run.rb
 #
 
-# Look for all required dependencies.
+# Load gloo from source, then run it with the command line's arguments.
 path = File.dirname( File.absolute_path( __FILE__ ) )
-require File.join( path, 'dependencies.rb' )
+require File.join( path, 'gloo.rb' )
 
-params = []
-( params << '--cli' ) if ARGV.count.zero?
-
-platform = Gloo::App::Platform.new
-context = Gloo::App::EngineContext.new(
-  params, platform, Gloo::App::Log, nil )
-Gloo::App::Engine.new( context ).start
+Gloo.run

data/test.gloo/app/embed.test.gloo

@@ -0,0 +1,31 @@
+#
+# Embedded gloo tests.
+# An engine created in code by another Ruby program uses only the
+# params it's given, never that program's command line (ARGV).
+# The engine running these tests was started as the command, so the
+# check runs a separate Ruby program (a fixture) with [system].
+#
+
+tests.app.embed [can] :
+
+  # The harness, beside this file; found with source_dir.
+  harness [string] : /fixtures/embed_harness.rb
+  host_arg [string] : host_arg.gloo
+  no_files [string] : 0
+  where [string] :
+
+  run_harness [system] :
+    command [string] :
+    get_output [bool] : true
+    result [string] :
+
+  ignores_host_argv [test] :
+    description [string] : An engine created in code ignores the host program's command line.
+    on_test [script] :
+      check ^^ for source_dir
+      put it into ^^.where
+      # Paths are quoted in case the folder has spaces.
+      put "ruby '" ^^.where ^^.harness "' " ^^.host_arg into ^^.run_harness.command
+      tell ^^.run_harness to run
+      eval ^^.run_harness.result = ^^.no_files
+      assert "expected the embedded engine to be given no files"

data/test.gloo/app/fixtures/embed_harness.rb

@@ -0,0 +1,15 @@
+#
+# A Ruby program that creates a gloo engine in code, as an embedding
+# app would, and prints how many files the engine was given.
+#
+# Run it with words on its own command line: the engine must not
+# take them as files, so this should always print 0. The engine is
+# never started, so nothing is loaded or saved even if it does.
+#
+# Requires this repo's lib/gloo by path, so it checks the source,
+# not an installed gloo gem.
+#
+require_relative '../../../lib/gloo'
+
+context = Gloo::App::EngineContext.new( [ '--quiet' ] )
+print Gloo::App::Engine.new( context ).args.files.count

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

@@ -20,6 +20,27 @@ tests.ctrl.each [can] :
       eval ^^.count + 1
       put it into ^^.count
 
+  seen [string] :
+  lines [text] : BEGIN
+one
+
+two
+END
+
+  lns [each] :
+    line [string] :
+    in [alias] : tests.ctrl.each.lines
+    do [script] :
+      put tests.ctrl.each.seen + '[' + ^.line + ']' into tests.ctrl.each.seen
+
+  each_line_without_line_endings [test] :
+    description [string] : each line gives each line without its line ending; a blank line is empty.
+    on_test [script] :
+      put '' into ^^.seen
+      tell ^^.lns to run
+      eval ^^.seen = '[one][][two]'
+      assert "expected each line without its line ending"
+
   each_word [test] :
     description [string] : Count words with each word
     on_test [script] :
@@ -137,3 +158,54 @@ tests.ctrl.each_folder [can] :
       eval ^^.count = 2
       assert "expected a and a/deep"
       tell ^^.remove_tree to run
+
+#
+# Each child with group_by: on_group_start sees the group's first
+# child and on_group_end its last. Each start and end logs the id of
+# the child it sees.
+#
+
+tests.ctrl.each_group [can] :
+
+  starts [string] :
+  ends [string] :
+
+  items [can] :
+    a [can] :
+      id [string] : a
+      kind [string] : x
+    b [can] :
+      id [string] : b
+      kind [string] : x
+    c [can] :
+      id [string] : c
+      kind [string] : y
+    d [can] :
+      id [string] : d
+      kind [string] : y
+
+  grouped [each] :
+    child [alias] :
+    in [alias] : tests.ctrl.each_group.items
+    group_by [string] : kind
+    on_group_start [script] :
+      put tests.ctrl.each_group.starts + tests.ctrl.each_group.grouped.child.id into tests.ctrl.each_group.starts
+    on_group_end [script] :
+      put tests.ctrl.each_group.ends + tests.ctrl.each_group.grouped.child.id into tests.ctrl.each_group.ends
+    do [script] :
+
+  group_start_sees_first_child [test] :
+    description [string] : on_group_start sees the first child of the new group.
+    on_test [script] :
+      put '' into ^^.starts
+      tell ^^.grouped to run
+      eval ^^.starts = 'ac'
+      assert "expected each group to start with its first child"
+
+  group_end_sees_last_child [test] :
+    description [string] : on_group_end sees the last child of the group that's ending.
+    on_test [script] :
+      put '' into ^^.ends
+      tell ^^.grouped to run
+      eval ^^.ends = 'bd'
+      assert "expected each group to end with its last child"

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/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/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/verbs/break.test.gloo

@@ -18,3 +18,69 @@ tests.verbs.break [can] :
       tell ^^.s to run
       eval ^^.b
       assert "expected b to be true"
+
+  # Loops whose do script breaks on its second pass.
+  passes [int] : 0
+  after [int] : 0
+
+  rep [repeat] :
+    times [int] : 4
+    index [int] :
+    do [script] :
+      put tests.verbs.break.passes + 1 into tests.verbs.break.passes
+      if tests.verbs.break.passes = 2 then break
+      put tests.verbs.break.after + 1 into tests.verbs.break.after
+
+  kids [can] :
+    a [string] : a
+    b [string] : b
+    c [string] : c
+
+  each_kid [each] :
+    child [alias] :
+    in [alias] : tests.verbs.break.kids
+    do [script] :
+      put tests.verbs.break.passes + 1 into tests.verbs.break.passes
+      if tests.verbs.break.passes = 2 then break
+      put tests.verbs.break.after + 1 into tests.verbs.break.after
+
+  inner [repeat] :
+    times [int] : 3
+    index [int] :
+    do [script] :
+      if tests.verbs.break.inner.index = 1 then break
+      put tests.verbs.break.after + 1 into tests.verbs.break.after
+
+  outer [repeat] :
+    times [int] : 2
+    index [int] :
+    do [script] :
+      tell tests.verbs.break.inner to run
+
+  break_ends_a_repeat [test] :
+    description [string] : break in a repeat's do script ends the loop.
+    on_test [script] :
+      put 0 into ^^.passes
+      put 0 into ^^.after
+      tell ^^.rep to run
+      eval ^^.passes = 2
+      assert "expected the loop to stop on the pass that broke"
+      eval ^^.after = 1
+      assert "expected only the first pass to get past the break"
+
+  break_ends_an_each [test] :
+    description [string] : break in an each's do script ends the loop.
+    on_test [script] :
+      put 0 into ^^.passes
+      put 0 into ^^.after
+      tell ^^.each_kid to run
+      eval ^^.passes = 2
+      assert "expected the loop to stop on the pass that broke"
+
+  break_ends_only_the_inner_loop [test] :
+    description [string] : break in an inner loop ends that loop, not the outer one.
+    on_test [script] :
+      put 0 into ^^.after
+      tell ^^.outer to run
+      eval ^^.after = 2
+      assert "expected each of the 2 inner loops to get past its break once"