hegeltest 0.3.1 → 0.4.0

data/lib/hegel/stateful/pool.rb

@@ -103,6 +103,58 @@ module Hegel
           @values.delete(variable_id)
           value
         end
+
+        # Consumes up to Filtered::MAX_ATTEMPTS ids and keeps only the one
+        # whose value +predicate+ accepts. hegel_pool_generate removes an id
+        # for good unless hegel_pool_restore puts it back, so a filter that
+        # drew through #do_draw would lose every value it rejected. Rejected
+        # ids stay consumed while the attempts run, so no attempt draws one
+        # again, and go back together once they are over. hegel-rust's
+        # ValuesConsumed (frontends/rust/src/stateful.rs) does the same.
+        def do_draw_filtered(tc, predicate)
+          attempted = []
+          accepted = nil
+          restore = true
+          begin
+            Filtered::MAX_ATTEMPTS.times do
+              # Once every value left was rejected, the engine has nothing
+              # more to draw.
+              break if @values.size == attempted.size
+
+              accepted = filtered_attempt(tc, predicate, attempted)
+              break if accepted
+            end
+          rescue *Hegel::FATAL_EXCEPTIONS
+            # The process is ending, and answering a NoMemoryError with
+            # native calls is the wrong move (see Hegel::Stateful.apply_rule).
+            restore = false
+            raise
+          ensure
+            (attempted - [accepted]).each { |variable_id| tc.pool_restore(@pool, variable_id) } if restore
+          end
+          raise Hegel::AssumeFailed unless accepted
+
+          @values.delete(accepted)
+        end
+
+        private
+
+        # One attempt, in a span of its own that closes as discarded unless
+        # the predicate accepts. Records the consumed id in +attempted+ before
+        # the predicate runs, so a predicate that raises still has its id put
+        # back. Returns the id when accepted, nil otherwise. +accepted+ stays
+        # nil, which discards the span, when a draw or the predicate raises.
+        def filtered_attempt(tc, predicate, attempted)
+          tc.start_span(Generator::FILTER_ATTEMPT_LABEL)
+          begin
+            variable_id = tc.pool_generate(@pool, true)
+            attempted << variable_id
+            accepted = predicate.call(@values.fetch(variable_id))
+            variable_id if accepted
+          ensure
+            tc.stop_span(discard: !accepted)
+          end
+        end
       end
     end
   end

data/lib/hegel/stateful.rb

@@ -43,7 +43,7 @@ module Hegel
 
       invariants = machine.class.invariant_definitions
       state_machine = tc.new_state_machine(
-        rules.keys, invariants.keys, invariants.values.map(&:always_run), step_count
+        rules.keys, rules.values.map(&:weight), invariants.keys, invariants.values.map(&:always_run), step_count
       )
       begin
         tc.note { "Initial invariant check." }
@@ -81,7 +81,7 @@ module Hegel
           name = rule_names[rule_index]
           steps_attempted += 1
           tc.note { "Step #{steps_attempted}: #{name}" }
-          rejected = true unless apply_rule(machine, rules.fetch(name), state_machine, tc)
+          rejected = true unless apply_rule(machine, rules.fetch(name).block, state_machine, tc)
         end
         tc.stop_span(discard: rejected)
         run_sampled_invariants(machine, invariants, state_machine, tc)

data/lib/hegel/syntax/methods.rb

@@ -27,26 +27,34 @@ module Hegel
       # A double in [min_value, max_value]. allow_nan and allow_infinity
       # default to what the bounds imply: NaN when the caller passed
       # neither bound, an infinity when the caller left either side open.
+      # allow_subnormal defaults to true whenever the bounds admit a
+      # subnormal.
       def floats(min_value: nil, max_value: nil, allow_nan: nil, allow_infinity: nil, exclude_min: false,
-        exclude_max: false)
+        exclude_max: false, allow_subnormal: nil)
         Generators::FloatGenerator.new(
           min_value: min_value, max_value: max_value, allow_nan: allow_nan, allow_infinity: allow_infinity,
-          exclude_min: exclude_min, exclude_max: exclude_max
+          exclude_min: exclude_min, exclude_max: exclude_max, allow_subnormal: allow_subnormal
         )
       end
 
-      # A Unicode string of [min_size, max_size] characters.
-      def text(min_size: 0, max_size: nil, codec: nil, min_codepoint: nil, max_codepoint: nil)
+      # A Unicode string of [min_size, max_size] characters; max_size
+      # defaults to 100, or min_size + 100 when min_size exceeds 100.
+      # +alphabet+ is a String of the permitted characters; it cannot be
+      # combined with the options after it.
+      def text(min_size: 0, max_size: nil, alphabet: nil, codec: nil, min_codepoint: nil, max_codepoint: nil,
+        categories: nil, exclude_categories: nil, include_characters: nil, exclude_characters: nil)
         Generators::TextGenerator.new(
-          min_size: min_size, max_size: max_size, codec: codec,
-          min_codepoint: min_codepoint, max_codepoint: max_codepoint
+          min_size: min_size, max_size: max_size, alphabet: alphabet, codec: codec,
+          min_codepoint: min_codepoint, max_codepoint: max_codepoint, categories: categories,
+          exclude_categories: exclude_categories, include_characters: include_characters,
+          exclude_characters: exclude_characters
         )
       end
 
       # An Array of values from +elements+, with [min_size, max_size]
-      # entries.
-      def arrays(elements, min_size: 0, max_size: nil)
-        Generators::ArrayGenerator.new(elements, min_size: min_size, max_size: max_size)
+      # entries. With unique: true, no two entries are equal.
+      def arrays(elements, min_size: 0, max_size: nil, unique: false)
+        Generators::ArrayGenerator.new(elements, min_size: min_size, max_size: max_size, unique: unique)
       end
 
       # Always +value+, drawing nothing.
@@ -59,6 +67,29 @@ module Hegel
         Generators::SampledFromGenerator.new(collection)
       end
 
+      # An Array holding every element of +elements+ (anything #sampled_from
+      # accepts) in an order the engine picks, shrinking towards the
+      # original one.
+      def permutations(elements)
+        Generators::PermutationsGenerator.new(elements)
+      end
+
+      # An Array holding [min_size, max_size] of the elements of +elements+,
+      # in their original order. Duplicate elements count as distinct.
+      def subsequences(elements, min_size: 0, max_size: nil)
+        Generators::SubsequencesGenerator.new(elements, min_size: min_size, max_size: max_size)
+      end
+
+      # An Array of [min_size, max_size] elements of +elements+. With
+      # +replacement+ (the default) each is drawn independently and the
+      # size is unbounded unless +max_size+ bounds it. Without it, each
+      # element is used at most once and the size is capped at the number
+      # of elements; hegel-rust names the two modes with_replacement and
+      # without_replacement.
+      def samples(elements, min_size: 0, max_size: nil, replacement: true)
+        Generators::SamplesGenerator.new(elements, min_size: min_size, max_size: max_size, replacement: replacement)
+      end
+
       # A value drawn from one of +generators+, picked at random.
       def one_of(*generators)
         Generators::OneOfGenerator.new(generators)
@@ -88,20 +119,41 @@ module Hegel
 
       # A String of exactly one character, sharing #text's own alphabet
       # options.
-      def characters(codec: nil, min_codepoint: nil, max_codepoint: nil)
-        Generators::CharactersGenerator.new(codec: codec, min_codepoint: min_codepoint, max_codepoint: max_codepoint)
+      def characters(codec: nil, min_codepoint: nil, max_codepoint: nil, categories: nil, exclude_categories: nil,
+        include_characters: nil, exclude_characters: nil)
+        Generators::CharactersGenerator.new(
+          codec: codec, min_codepoint: min_codepoint, max_codepoint: max_codepoint, categories: categories,
+          exclude_categories: exclude_categories, include_characters: include_characters,
+          exclude_characters: exclude_characters
+        )
       end
 
-      # A byte String of [min_size, max_size] bytes.
+      # A byte String of [min_size, max_size] bytes; max_size defaults as
+      # in #text.
       def binary(min_size: 0, max_size: nil)
         Generators::BinaryGenerator.new(min_size: min_size, max_size: max_size)
       end
 
       # A String matching +pattern+ (Python `re` syntax, not Ruby's
       # Regexp syntax; see Generators::FromRegexGenerator). fullmatch
-      # requires the whole string to match, not just contain a match.
-      def from_regex(pattern, fullmatch: false)
-        Generators::FromRegexGenerator.new(pattern, fullmatch: fullmatch)
+      # (the default) requires the whole string to match, not just contain
+      # a match.
+      # +alphabet+ is a #characters generator limiting every character of the
+      # string.
+      def from_regex(pattern, fullmatch: true, alphabet: nil)
+        Generators::FromRegexGenerator.new(pattern, fullmatch: fullmatch, alphabet: alphabet)
+      end
+
+      # A String that +grammar+, written in the syntax of the Lark parsing
+      # library, accepts from its +start+ rule. +explicit+ maps terminal names
+      # to generators of the values drawn for them, +alphabet+ is a
+      # #characters generator limiting what terminal patterns draw, and
+      # +import_path+ is the directory %import reads files from.
+      def from_lark(grammar, start: nil, explicit: {}, alphabet: nil, max_size: nil, max_depth: nil, import_path: nil)
+        Generators::FromLarkGenerator.new(
+          grammar, start: start, explicit: explicit, alphabet: alphabet, max_size: max_size, max_depth: max_depth,
+          import_path: import_path
+        )
       end
 
       # An RFC 5321/5322 email address String.
@@ -152,6 +204,29 @@ module Hegel
         Generators::DatetimesGenerator.new(min_value: min_value, max_value: max_value)
       end
 
+      # A "YYYY-MM-DD" String, years 1 through 9999. Takes no options.
+      def date_strings
+        Generators::DateStringsGenerator.new
+      end
+
+      # An "HH:MM:SS" String, with ".fffffffff" appended when the
+      # nanosecond is not zero. Takes no options.
+      def time_strings
+        Generators::TimeStringsGenerator.new
+      end
+
+      # A "YYYY-MM-DDTHH:MM:SS[.fffffffff]" String, years 1 through 9999.
+      # Takes no options.
+      def datetime_strings
+        Generators::DatetimeStringsGenerator.new
+      end
+
+      # A duration as Integer nanoseconds in [min_value, max_value], up to
+      # 2**64 - 1 (see Generators::DurationsGenerator and docs/adr/0030).
+      def durations(min_value: 0, max_value: (2**64) - 1)
+        Generators::DurationsGenerator.new(min_value: min_value, max_value: max_value)
+      end
+
       # A value built from imperative code: +block+ receives a draw
       # surface and may call #draw on it any number of times to assemble
       # one value (see Generators::CompositeGenerator).
@@ -165,6 +240,15 @@ module Hegel
       def deferred
         Generators::DeferredGenerator.new
       end
+
+      # A recursively defined value, such as a tree: either a value from
+      # +leaf+, or what the block's generator builds from sub-values of the
+      # same kind (see Generators::RecursiveGenerator). The block receives
+      # the generator of those sub-values and is called afresh for each
+      # branch.
+      def recursive(leaf, max_depth: 32, max_leaves: 100, &branch)
+        Generators::RecursiveGenerator.new(leaf, max_depth: max_depth, max_leaves: max_leaves, &branch)
+      end
     end
   end