opal-connect-rspec 0.5.0

data/rspec-core/lib/rspec/core/version.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Core
+    # Version information for RSpec Core.
+    module Version
+      # Current version of RSpec Core, in semantic versioning format.
+      STRING = '3.1.7'
+    end
+  end
+end

data/rspec-core/lib/rspec/core/warnings.rb

@@ -0,0 +1,40 @@
+require "rspec/support/warnings"
+
+module RSpec
+  module Core
+    # @private
+    module Warnings
+      # @private
+      #
+      # Used internally to print deprecation warnings
+      def deprecate(deprecated, data={})
+        RSpec.configuration.reporter.deprecation(
+          {
+            :deprecated => deprecated,
+            :call_site => CallerFilter.first_non_rspec_line
+          }.merge(data)
+        )
+      end
+
+      # @private
+      #
+      # Used internally to print deprecation warnings
+      def warn_deprecation(message, opts={})
+        RSpec.configuration.reporter.deprecation opts.merge(:message => message)
+      end
+
+      # @private
+      def warn_with(message, options={})
+        if options[:use_spec_location_as_call_site]
+          message += "." unless message.end_with?(".")
+
+          if RSpec.current_example
+            message += " Warning generated from spec at `#{RSpec.current_example.location}`."
+          end
+        end
+
+        super(message, options)
+      end
+    end
+  end
+end

data/rspec-core/lib/rspec/core/world.rb

@@ -0,0 +1,183 @@
+require 'rbconfig'
+
+module RSpec
+  module Core
+    # @api private
+    #
+    # Internal container for global non-configuration data
+    class World
+      include RSpec::Core::Hooks
+
+      # @private
+      attr_reader :example_groups, :filtered_examples
+
+      # Used internally to determine what to do when a SIGINT is received
+      attr_accessor :wants_to_quit
+
+      def initialize(configuration=RSpec.configuration)
+        @configuration = configuration
+        @example_groups = []
+        @filtered_examples = Hash.new do |hash, group|
+          hash[group] = begin
+            examples = group.examples.dup
+            examples = filter_manager.prune(examples)
+            examples.uniq!
+            examples
+          end
+        end
+      end
+
+      # @private
+      # Used internally to clear remaining groups when fail_fast is set
+      def clear_remaining_example_groups
+        example_groups.clear
+      end
+
+      # @private
+      def windows_os?
+        RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+      end
+
+      # @api private
+      #
+      # Apply ordering strategy from configuration to example groups
+      def ordered_example_groups
+        ordering_strategy = @configuration.ordering_registry.fetch(:global)
+        ordering_strategy.order(@example_groups)
+      end
+
+      # @api private
+      #
+      # Reset world to 'scratch' before running suite
+      def reset
+        example_groups.clear
+        @shared_example_group_registry = nil
+      end
+
+      # @private
+      def filter_manager
+        @configuration.filter_manager
+      end
+
+      # @api private
+      #
+      # Register an example group
+      def register(example_group)
+        example_groups << example_group
+        example_group
+      end
+
+      # @private
+      def shared_example_group_registry
+        @shared_example_group_registry ||= SharedExampleGroup::Registry.new
+      end
+
+      # @private
+      def inclusion_filter
+        @configuration.inclusion_filter
+      end
+
+      # @private
+      def exclusion_filter
+        @configuration.exclusion_filter
+      end
+
+      # @private
+      def configure_group(group)
+        @configuration.configure_group(group)
+      end
+
+      # @api private
+      #
+      # Get count of examples to be run
+      def example_count(groups=example_groups)
+        FlatMap.flat_map(groups) { |g| g.descendants }.
+          inject(0) { |a, e| a + e.filtered_examples.size }
+      end
+
+      # @api private
+      #
+      # Find line number of previous declaration
+      def preceding_declaration_line(filter_line)
+        declaration_line_numbers.sort.inject(nil) do |highest_prior_declaration_line, line|
+          line <= filter_line ? line : highest_prior_declaration_line
+        end
+      end
+
+      # @private
+      def reporter
+        @configuration.reporter
+      end
+
+      # @api private
+      #
+      # Notify reporter of filters
+      def announce_filters
+        filter_announcements = []
+
+        announce_inclusion_filter filter_announcements
+        announce_exclusion_filter filter_announcements
+
+        unless filter_manager.empty?
+          if filter_announcements.length == 1
+            reporter.message("Run options: #{filter_announcements[0]}")
+          else
+            reporter.message("Run options:\n  #{filter_announcements.join("\n  ")}")
+          end
+        end
+
+        if @configuration.run_all_when_everything_filtered? && example_count.zero?
+          reporter.message("#{everything_filtered_message}; ignoring #{inclusion_filter.description}")
+          filtered_examples.clear
+          inclusion_filter.clear
+        end
+
+        return unless example_count.zero?
+
+        example_groups.clear
+        if filter_manager.empty?
+          reporter.message("No examples found.")
+        elsif exclusion_filter.empty?
+          message = everything_filtered_message
+          if @configuration.run_all_when_everything_filtered?
+            message << "; ignoring #{inclusion_filter.description}"
+          end
+          reporter.message(message)
+        elsif inclusion_filter.empty?
+          reporter.message(everything_filtered_message)
+        end
+      end
+
+      # @private
+      def everything_filtered_message
+        "\nAll examples were filtered out"
+      end
+
+      # @api private
+      #
+      # Add inclusion filters to announcement message
+      def announce_inclusion_filter(announcements)
+        return if inclusion_filter.empty?
+
+        announcements << "include #{inclusion_filter.description}"
+      end
+
+      # @api private
+      #
+      # Add exclusion filters to announcement message
+      def announce_exclusion_filter(announcements)
+        return if exclusion_filter.empty?
+
+        announcements << "exclude #{exclusion_filter.description}"
+      end
+
+    private
+
+      def declaration_line_numbers
+        @line_numbers ||= example_groups.inject([]) do |lines, g|
+          lines + g.declaration_line_numbers
+        end
+      end
+    end
+  end
+end

data/rspec-core/spec/command_line/order_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+RSpec.describe 'command line', :ui, :slow do
+  let(:stderr) { StringIO.new }
+  let(:stdout) { StringIO.new }
+
+  before :all do
+    write_file 'spec/simple_spec.rb', """
+      RSpec.describe 'group 1' do
+        specify('group 1 example 1') {}
+        specify('group 1 example 2') {}
+        specify('group 1 example 3') {}
+        describe 'group 1-1' do
+          specify('group 1-1 example 1') {}
+          specify('group 1-1 example 2') {}
+          specify('group 1-1 example 3') {}
+        end
+      end
+    """
+
+    write_file 'spec/simple_spec2.rb', """
+      RSpec.describe 'group 2' do
+        specify('group 2 example 1') {}
+        specify('group 2 example 2') {}
+        specify('group 2 example 3') {}
+        describe 'group 2-1' do
+          specify('group 2-1 example 1') {}
+          specify('group 2-1 example 2') {}
+          specify('group 2-1 example 3') {}
+        end
+      end
+    """
+
+    write_file 'spec/order_spec.rb', """
+      RSpec.describe 'group 1' do
+        specify('group 1 example 1')  {}
+        specify('group 1 example 2')  {}
+        specify('group 1 example 3')  {}
+        specify('group 1 example 4')  {}
+        specify('group 1 example 5')  {}
+        specify('group 1 example 6')  {}
+        specify('group 1 example 7')  {}
+        specify('group 1 example 8')  {}
+        specify('group 1 example 9')  {}
+        specify('group 1 example 10') {}
+
+        describe 'group 1-1' do
+          specify('group 1-1 example 1')  {}
+          specify('group 1-1 example 2')  {}
+          specify('group 1-1 example 3')  {}
+          specify('group 1-1 example 4')  {}
+          specify('group 1-1 example 5')  {}
+          specify('group 1-1 example 6')  {}
+          specify('group 1-1 example 7')  {}
+          specify('group 1-1 example 8')  {}
+          specify('group 1-1 example 9')  {}
+          specify('group 1-1 example 10') {}
+        end
+
+        describe('group 1-2')  { specify('example') {} }
+        describe('group 1-3')  { specify('example') {} }
+        describe('group 1-4')  { specify('example') {} }
+        describe('group 1-5')  { specify('example') {} }
+        describe('group 1-6')  { specify('example') {} }
+        describe('group 1-7')  { specify('example') {} }
+        describe('group 1-8')  { specify('example') {} }
+        describe('group 1-9')  { specify('example') {} }
+        describe('group 1-10') { specify('example') {} }
+      end
+
+      RSpec.describe('group 2')  { specify('example') {} }
+      RSpec.describe('group 3')  { specify('example') {} }
+      RSpec.describe('group 4')  { specify('example') {} }
+      RSpec.describe('group 5')  { specify('example') {} }
+      RSpec.describe('group 6')  { specify('example') {} }
+      RSpec.describe('group 7')  { specify('example') {} }
+      RSpec.describe('group 8')  { specify('example') {} }
+      RSpec.describe('group 9')  { specify('example') {} }
+      RSpec.describe('group 10') { specify('example') {} }
+    """
+  end
+
+  describe '--order rand' do
+    it 'runs the examples and groups in a different order each time' do
+      run_command 'spec/order_spec.rb --order rand -f doc'
+      original_seed = srand
+      RSpec.configuration.seed = srand # reset seed in same process
+      run_command 'spec/order_spec.rb --order rand -f doc'
+      srand original_seed
+
+      expect(stdout.string).to match(/Randomized with seed \d+/)
+
+      top_level_groups      {|first_run, second_run| expect(first_run).to_not eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to_not eq(second_run)}
+      examples('group 1')   {|first_run, second_run| expect(first_run).to_not eq(second_run)}
+      examples('group 1-1') {|first_run, second_run| expect(first_run).to_not eq(second_run)}
+    end
+  end
+
+  describe '--order rand:SEED' do
+    it 'runs the examples and groups in the same order each time' do
+      2.times { run_command 'spec/order_spec.rb --order rand:123 -f doc' }
+
+      expect(stdout.string).to match(/Randomized with seed 123/)
+
+      top_level_groups      {|first_run, second_run| expect(first_run).to eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1')   {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1-1') {|first_run, second_run| expect(first_run).to eq(second_run)}
+    end
+  end
+
+  describe '--seed SEED' do
+    it "forces '--order rand' and runs the examples and groups in the same order each time" do
+      2.times { run_command 'spec/order_spec.rb --seed 123 -f doc' }
+
+      expect(stdout.string).to match(/Randomized with seed 123/)
+
+      top_level_groups      {|first_run, second_run| expect(first_run).to eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1')   {|first_run, second_run| expect(first_run).to eq(second_run)}
+      examples('group 1-1') {|first_run, second_run| expect(first_run).to eq(second_run)}
+    end
+
+    it "runs examples in the same order, regardless of the order in which files are given" do
+      run_command 'spec/simple_spec.rb spec/simple_spec2.rb --seed 1337 -f doc'
+      run_command 'spec/simple_spec2.rb spec/simple_spec.rb --seed 1337 -f doc'
+
+      top_level_groups      {|first_run, second_run| expect(first_run).to eq(second_run)}
+      nested_groups         {|first_run, second_run| expect(first_run).to eq(second_run)}
+    end
+  end
+
+  describe '--order defined on CLI with --order rand in .rspec' do
+    after { remove_file '.rspec' }
+
+    it "overrides --order rand with --order defined" do
+      write_file '.rspec', '--order rand'
+
+      run_command 'spec/order_spec.rb --order defined -f doc'
+
+      expect(stdout.string).not_to match(/Randomized/)
+
+      expect(stdout.string).to match(
+        /group 1.*group 1 example 1.*group 1 example 2.*group 1-1.*group 1-2.*group 2.*/m
+      )
+    end
+  end
+
+  context 'when a custom order is configured' do
+    after { remove_file 'spec/custom_order_spec.rb' }
+
+    before do
+      write_file 'spec/custom_order_spec.rb', """
+        RSpec.configure do |config|
+          config.register_ordering :global do |list|
+            list.sort_by { |item| item.description }
+          end
+        end
+
+        RSpec.describe 'group B' do
+          specify('group B example D')  {}
+          specify('group B example B')  {}
+          specify('group B example A')  {}
+          specify('group B example C')  {}
+        end
+
+        RSpec.describe 'group A' do
+          specify('group A example 1')  {}
+        end
+      """
+    end
+
+    it 'orders the groups and examples by the provided strategy' do
+      run_command 'spec/custom_order_spec.rb -f doc'
+
+      top_level_groups    { |groups| expect(groups.flatten).to eq(['group A', 'group B']) }
+      examples('group B') do |examples|
+        letters = examples.flatten.map { |e| e[/(.)\z/, 1] }
+        expect(letters).to eq(['A', 'B', 'C', 'D'])
+      end
+    end
+  end
+
+  def examples(group)
+    yield split_in_half(stdout.string.scan(/^\s+#{group} example.*$/))
+  end
+
+  def top_level_groups
+    yield example_groups_at_level(0)
+  end
+
+  def nested_groups
+    yield example_groups_at_level(2)
+  end
+
+  def example_groups_at_level(level)
+    split_in_half(stdout.string.scan(/^\s{#{level*2}}group.*$/))
+  end
+
+  def split_in_half(array)
+    length, midpoint = array.length, array.length / 2
+    return array.slice(0, midpoint), array.slice(midpoint, length)
+  end
+
+  def run_command(cmd)
+    in_current_dir do
+      RSpec::Core::Runner.run(cmd.split, stderr, stdout)
+    end
+  ensure
+    RSpec.reset
+  end
+end

data/rspec-core/spec/rspec/core/backtrace_formatter_spec.rb

@@ -0,0 +1,306 @@
+require "spec_helper"
+
+module RSpec::Core
+  RSpec.describe BacktraceFormatter do
+    def make_backtrace_formatter(exclusion_patterns=nil, inclusion_patterns=nil)
+      BacktraceFormatter.new.tap do |bc|
+        bc.exclusion_patterns = exclusion_patterns if exclusion_patterns
+        bc.inclusion_patterns = inclusion_patterns if inclusion_patterns
+      end
+    end
+
+    describe "defaults" do
+      it "excludes rspec files" do
+        expect(make_backtrace_formatter.exclude?("/lib/rspec/core.rb")).to be true
+        expect(make_backtrace_formatter.exclude?("/lib/rspec/core/foo.rb")).to be true
+        expect(make_backtrace_formatter.exclude?("/lib/rspec/expectations/foo.rb")).to be true
+        expect(make_backtrace_formatter.exclude?("/lib/rspec/matchers/foo.rb")).to be true
+        expect(make_backtrace_formatter.exclude?("/lib/rspec/mocks/foo.rb")).to be true
+        expect(make_backtrace_formatter.exclude?("/lib/rspec/support/foo.rb")).to be true
+      end
+
+      it "excludes the rspec binary, even when rspec-core has installed as a bundler :git dependency" do
+        expect(make_backtrace_formatter.exclude?("exe/rspec")).to be true
+      end
+
+      it "excludes java files (for JRuby)", :if => (RUBY_PLATFORM == 'java')  do
+        expect(make_backtrace_formatter.exclude?("org/jruby/RubyArray.java:2336")).to be true
+      end
+
+      it "includes files in projects containing 'gems' in the name" do
+        expect(make_backtrace_formatter.exclude?('code/my-gems-plugin/lib/plugin.rb')).to be false
+      end
+
+      it "includes something in the current working directory" do
+        expect(make_backtrace_formatter.exclude?("#{Dir.getwd}/arbitrary")).to be false
+      end
+
+      it 'allows users to exclude their bundler vendor directory' do
+        formatter = make_backtrace_formatter([%r{/vendor/bundle/}])
+        vendored_gem_line = File.join(Dir.getwd, "vendor/bundle/gems/mygem-4.1.6/lib/my_gem:241")
+        expect(formatter.exclude? vendored_gem_line).to be true
+      end
+
+      context "when the exclusion list has been replaced" do
+        it "includes a line that the default patterns exclude" do
+          formatter = make_backtrace_formatter
+          expect {
+            formatter = make_backtrace_formatter([/spec_helper/])
+          }.to change { formatter.exclude? "/path/to/lib/rspec/expectations/foo.rb" }.from(true).to(false)
+        end
+      end
+
+      context "when the current working directory includes `gems` in the name" do
+        around(:example) do |ex|
+          Dir.mktmpdir do |tmp_dir|
+            dir = File.join(tmp_dir, "gems")
+            Dir.mkdir(dir)
+            Dir.chdir(dir, &ex)
+          end
+        end
+
+        it "includes something in the current working directory" do
+          expect(make_backtrace_formatter.exclude?("#{Dir.getwd}/arbitrary")).to be false
+        end
+      end
+    end
+
+    describe "#filter_gem" do
+      shared_examples_for "filtering a gem" do |gem_name, path|
+        it 'filters backtrace lines for the named gem' do
+          formatter = BacktraceFormatter.new
+          line      = File.join(path, "lib", "foo.rb:13")
+
+          expect {
+            formatter.filter_gem gem_name
+          }.to change { formatter.exclude?(line) }.from(false).to(true)
+        end
+      end
+
+      context "for a gem installed globally as a system gem" do
+        include_examples "filtering a gem", "foo",
+          "/Users/myron/.gem/ruby/2.1.1/gems/foo-1.6.3.1"
+      end
+
+      context "for a gem installed in a vendored bundler path" do
+        include_examples "filtering a gem", "foo",
+          "/Users/myron/code/my_project/bundle/ruby/2.1.0/gems/foo-0.3.6"
+      end
+
+      context "for a gem installed by bundler as a :git dependency" do
+        include_examples "filtering a gem", "foo",
+          "/Users/myron/code/my_project/bundle/ruby/2.1.0/bundler/gems/foo-2b826653e1f5"
+      end
+
+      context "for a gem sourced from a local path" do
+        include_examples "filtering a gem", "foo", "/Users/myron/code/foo"
+      end
+
+      context "when vendored under the working directory" do
+        include_examples "filtering a gem", "foo",
+          File.join(Dir.getwd, "bundle/ruby/2.1.0/bundler/gems/foo-0.3.6")
+      end
+    end
+
+    describe "#format_backtrace" do
+      it "excludes lines from rspec libs by default", :unless => RSpec.world.windows_os? do
+        backtrace = [
+          "/path/to/rspec-expectations/lib/rspec/expectations/foo.rb:37",
+          "/path/to/rspec-expectations/lib/rspec/matchers/foo.rb:37",
+          "./my_spec.rb:5",
+          "/path/to/rspec-mocks/lib/rspec/mocks/foo.rb:37",
+          "/path/to/rspec-core/lib/rspec/core/foo.rb:37"
+        ]
+
+        expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq(["./my_spec.rb:5"])
+      end
+
+      it "excludes lines from rspec libs by default", :if => RSpec.world.windows_os? do
+        backtrace = [
+          "\\path\\to\\rspec-expectations\\lib\\rspec\\expectations\\foo.rb:37",
+          "\\path\\to\\rspec-expectations\\lib\\rspec\\matchers\\foo.rb:37",
+          ".\\my_spec.rb:5",
+          "\\path\\to\\rspec-mocks\\lib\\rspec\\mocks\\foo.rb:37",
+          "\\path\\to\\rspec-core\\lib\\rspec\\core\\foo.rb:37"
+        ]
+
+        expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq([".\\my_spec.rb:5"])
+      end
+
+      context "when every line is filtered out" do
+        let(:backtrace) do
+          [
+            "/path/to/rspec-expectations/lib/rspec/expectations/foo.rb:37",
+            "/path/to/rspec-expectations/lib/rspec/matchers/foo.rb:37",
+            "/path/to/rspec-mocks/lib/rspec/mocks/foo.rb:37",
+            "/path/to/rspec-core/lib/rspec/core/foo.rb:37"
+          ]
+        end
+
+        it "includes full backtrace" do
+          expect(BacktraceFormatter.new.format_backtrace(backtrace).take(4)).to eq backtrace
+        end
+
+        it "adds a message explaining everything was filtered" do
+          expect(BacktraceFormatter.new.format_backtrace(backtrace).drop(4).join).to match(/Showing full backtrace/)
+        end
+      end
+
+      context "when rspec is installed in the current working directory" do
+        it "excludes lines from rspec libs by default", :unless => RSpec.world.windows_os? do
+          backtrace = [
+            "#{Dir.getwd}/.bundle/path/to/rspec-expectations/lib/rspec/expectations/foo.rb:37",
+            "#{Dir.getwd}/.bundle/path/to/rspec-expectations/lib/rspec/matchers/foo.rb:37",
+            "#{Dir.getwd}/my_spec.rb:5",
+            "#{Dir.getwd}/.bundle/path/to/rspec-mocks/lib/rspec/mocks/foo.rb:37",
+            "#{Dir.getwd}/.bundle/path/to/rspec-core/lib/rspec/core/foo.rb:37"
+          ]
+
+          expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq(["./my_spec.rb:5"])
+        end
+      end
+    end
+
+    describe "#full_backtrace=true" do
+      it "sets full_backtrace true" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        formatter.full_backtrace = true
+        expect(formatter.full_backtrace?).to be true
+      end
+
+      it "preserves exclusion and inclusion patterns" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        formatter.full_backtrace = true
+        expect(formatter.exclusion_patterns).to eq [/discard/]
+        expect(formatter.inclusion_patterns).to eq [/keep/]
+      end
+
+      it "keeps all lines, even those that match exclusions" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        formatter.full_backtrace = true
+        expect(formatter.exclude? "discard").to be false
+      end
+    end
+
+    describe "#full_backtrace=false (after it was true)" do
+      it "sets full_backtrace false" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        formatter.full_backtrace = true
+        formatter.full_backtrace = false
+        expect(formatter.full_backtrace?).to be false
+      end
+
+      it "preserves exclusion and inclusion patterns" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        formatter.full_backtrace = true
+        formatter.full_backtrace = false
+        expect(formatter.exclusion_patterns).to eq [/discard/]
+        expect(formatter.inclusion_patterns).to eq [/keep/]
+      end
+
+      it "excludes lines that match exclusions" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        formatter.full_backtrace = true
+        formatter.full_backtrace = false
+        expect(formatter.exclude? "discard").to be true
+      end
+    end
+
+    describe "#backtrace_line" do
+      let(:formatter) { BacktraceFormatter.new }
+
+      it "trims current working directory" do
+        expect(formatter.__send__(:backtrace_line, File.expand_path(__FILE__))).to eq("./spec/rspec/core/backtrace_formatter_spec.rb")
+      end
+
+      it "preserves the original line" do
+        original_line = File.expand_path(__FILE__)
+        formatter.__send__(:backtrace_line, original_line)
+        expect(original_line).to eq(File.expand_path(__FILE__))
+      end
+
+      it "deals gracefully with a security error" do
+        safely do
+          formatter.__send__(:backtrace_line, __FILE__)
+          # on some rubies, this doesn't raise a SecurityError; this test just
+          # assures that if it *does* raise an error, the error is caught inside
+        end
+      end
+    end
+
+    context "when the current directory matches one of the default exclusion patterns" do
+      include_context "isolated directory"
+
+      around do |ex|
+        FileUtils.mkdir_p("bin")
+        Dir.chdir("./bin", &ex)
+      end
+
+      let(:line) { File.join(Dir.getwd, "foo.rb:13") }
+
+      it 'does not exclude lines from files in the current directory' do
+        expect(make_backtrace_formatter.exclude? line).to be false
+      end
+
+      context "with inclusion_patterns cleared" do
+        it 'excludes lines from files in the current directory' do
+          formatter = make_backtrace_formatter
+          formatter.inclusion_patterns.clear
+
+          expect(formatter.exclude? line).to be true
+        end
+      end
+    end
+
+    context "with no patterns" do
+      it "keeps all lines" do
+        lines = ["/tmp/a_file", "some_random_text", "hello\330\271!"]
+        formatter = make_backtrace_formatter([], [])
+        expect(lines.all? {|line| formatter.exclude? line}).to be false
+      end
+
+      it "is considered a full backtrace" do
+        expect(make_backtrace_formatter([], []).full_backtrace?).to be true
+      end
+    end
+
+    context "with an exclusion pattern but no inclusion patterns" do
+      it "excludes lines that match the exclusion pattern" do
+        formatter = make_backtrace_formatter([/discard/],[])
+        expect(formatter.exclude? "discard me").to be true
+      end
+
+      it "keeps lines that do not match the exclusion pattern" do
+        formatter = make_backtrace_formatter([/discard/],[])
+        expect(formatter.exclude? "apple").to be false
+      end
+
+      it "is considered a partial backtrace" do
+        formatter = make_backtrace_formatter([/discard/],[])
+        expect(formatter.full_backtrace?).to be false
+      end
+    end
+
+    context "with an exclusion pattern and an inclusion pattern" do
+      it "excludes lines that match the exclusion pattern but not the inclusion pattern" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        expect(formatter.exclude? "discard").to be true
+      end
+
+      it "keeps lines that match both patterns" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        expect(formatter.exclude? "discard/keep").to be false
+      end
+
+      it "keeps lines that match neither pattern" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        expect(formatter.exclude? "fish").to be false
+      end
+
+      it "is considered a partial backtrace" do
+        formatter = make_backtrace_formatter([/discard/],[/keep/])
+        expect(formatter.full_backtrace?).to be false
+      end
+    end
+  end
+end