edl 0.1.5 → 0.1.6

data/test/samples/45S_SAMPLE.EDL

@@ -1,48 +0,0 @@
-TITLE:   EDIT 15 [14-11-08] 45 SEC EDL 
-001  106771   V     C        04:00:57:05 04:00:58:10 10:00:00:00 10:00:01:05 
-002  106771   V     C        04:03:44:06 04:03:45:08 10:00:01:05 10:00:02:07 
-003  106770   V     C        00:06:55:13 00:06:57:01 10:00:02:07 10:00:03:20 
-004  106771   V     C        03:16:35:05 03:16:36:05 10:00:03:20 10:00:04:20 
-005  106770   V     C        00:13:03:17 00:13:04:20 10:00:04:20 10:00:05:23 
-006  106771   V     C        03:11:43:02 03:11:44:04 10:00:05:23 10:00:07:00 
-007  106857   V     C        07:18:40:24 07:18:41:17 10:00:07:00 10:00:07:18 
-008  106857   V     C        07:22:25:19 07:22:27:02 10:00:07:18 10:00:09:01 
-009  106863   V     C        13:12:46:23 13:12:48:11 10:00:09:01 10:00:10:14 
-010  106857   V     C        08:00:32:00 08:00:33:10 10:00:10:14 10:00:11:24 
-011  106857   V     C        08:05:36:18 08:05:37:19 10:00:11:24 10:00:13:00 
-012  106857   V     C        07:04:47:06 07:04:50:13 10:00:13:00 10:00:16:07 
-M2   106857         012.5                07:04:47:06 
-013  106863   V     C        10:11:06:07 10:11:08:00 10:00:16:07 10:00:18:00 
-014  106863   V     C        10:09:16:21 10:09:18:11 10:00:18:00 10:00:19:15 
-015  106857   V     C        07:06:02:17 07:06:04:07 10:00:19:15 10:00:21:05 
-016  106857   V     C        09:07:18:07 09:07:20:16 10:00:21:05 10:00:23:14 
-M2   106857         002.5                09:07:18:07 
-017  106863   V     C        11:02:46:06 11:02:47:06 10:00:23:14 10:00:24:14 
-018  106863   V     C        11:10:17:04 11:10:17:20 10:00:24:14 10:00:25:05 
-019  106863   V     C        12:06:09:18 12:06:10:16 10:00:25:05 10:00:26:03 
-020  106863   V     C        12:10:49:17 12:10:51:02 10:00:26:03 10:00:27:13 
-021  106815   V     C        05:01:22:21 05:01:24:05 10:00:27:13 10:00:28:22 
-022  106815   V     C        06:01:35:03 06:01:36:18 10:00:28:22 10:00:30:12 
-023  106815   V     C        05:13:38:19 05:13:40:10 10:00:30:12 10:00:32:03 
-M2   106815        -025.0                05:13:38:19 
-024  106857   V     C        09:13:03:09 09:13:05:11 10:00:32:03 10:00:34:05 
-M2   106857        -025.0                09:13:03:09 
-025  106857   V     C        09:13:01:07 09:13:01:07 10:00:34:05 10:00:34:05 
-025  106771   V     D    022 03:11:55:00 03:11:56:17 10:00:34:05 10:00:35:22 
-M2   106857        -025.0                09:13:01:07 
-* BLEND, DISSOLVE 
-026  106771   V     C        03:11:56:17 03:11:56:17 10:00:35:22 10:00:35:22 
-026  106771   V     D    012 03:06:30:09 03:06:31:19 10:00:35:22 10:00:37:07 
-* BLEND, DISSOLVE 
-027  106863   V     C        13:15:29:20 13:15:31:02 10:00:37:07 10:00:38:14 
-028  106771   V     C        03:15:40:22 03:15:42:11 10:00:38:14 10:00:40:03 
-029  106863   V     C        13:15:51:02 13:15:52:08 10:00:40:03 10:00:41:09 
-030  106863   V     C        13:15:52:08 13:15:52:08 10:00:41:09 10:00:41:09 
-030     BL    V     D    032 00:00:00:00 00:00:01:07 10:00:41:09 10:00:42:16 
-* BLEND, DISSOLVE 
->>> SOURCE 106770   106770           4919975f.793b8d33 
->>> SOURCE 106771   106771           4919a179.79630563 
->>> SOURCE 106815   106815           4919b521.79afcb70 
->>> SOURCE 106857   106857           4919cbb9.7a080d9d 
->>> SOURCE 106863   106863           4919e0c3.7a5a3cfc 
-

data/test/samples/FCP_REVERSE.EDL

@@ -1,9 +0,0 @@
-TITLE: REVSIMPLE
-FCM: NON-DROP FRAME
-
-001  FOO      V     C        01:00:39:23 01:01:19:23 01:00:00:00 01:00:40:00  
-* FROM CLIP NAME:  BARS_40S.MOV
-* COMMENT: 
-M2   FOO           -025.0                01:00:39:23
-
-

data/test/samples/KEY_TRANSITION.EDL

@@ -1,9 +0,0 @@
-TITLE: FOR_TEST
-FCM: DROP FRAME
-
-002        AX V     K B      00:01:06:06 00:01:08:03 01:00:04:10 01:00:06:07  
-002        AX V     K    000 00:00:03:08 00:00:03:08 01:00:04:10 01:00:04:10  
-* FROM CLIP NAME:  foobarz_0118_023-APPLE PRORES WITH ALPHA.MOV
-* COMMENT: 
-* KEY CLIP NAME:  foobarz_0118_026-APPLE PRORES WITH ALPHA.MOV
-* CLIP FILTER: COLOR CORRECTOR 3-WAY

data/test/samples/PLATES.EDL

@@ -1 +0,0 @@
-TITLE:   PLATES.

data/test/samples/REEL_IS_CLIP.txt

@@ -1,8 +0,0 @@
-0001 KASS1 A1234V C        00:00:00:00 00:00:12:24  10:00:00:00 10:00:12:24
-* REEL RC100009 IS CLIP 28661.mov
-0002 KASS1 A1234V C        00:00:00:00 00:00:13:03  10:00:12:24 10:00:26:02
-* REEL RC100003 IS CLIP 28655.mov
-0003 KASS1 A1234V C        00:00:00:00 00:00:15:06  10:00:26:02 10:00:41:08
-* REEL RC100005 IS CLIP 28657.mov
-0004 KASS1 A1234V C        00:00:00:00 00:00:16:06  10:00:41:08 10:00:57:14
-* REEL RC100010 IS CLIP 28662.mov

data/test/samples/REVERSE.EDL

@@ -1,3 +0,0 @@
-TITLE:   REVERSED_EDL 
-001  106857   V     C        09:13:03:09 09:13:05:11 10:00:32:03 10:00:34:05 
-M2   106857        -025.0                09:13:03:09 

data/test/samples/SIMPLE_DISSOLVE.EDL

@@ -1,9 +0,0 @@
-TITLE: SIMPLE_DISSOLVE
-FCM: NON-DROP FRAME
-
-001        BL V     C        00:00:00:00 00:00:00:00 01:00:00:00 01:00:00:00  
-001  006I     V     D    043 06:42:50:18 06:42:52:13 01:00:00:00 01:00:01:20  
-* EFFECT NAME: CROSS DISSOLVE
-* TO CLIP NAME:  TAPE_6-10.MOV
-* COMMENT: 
-

data/test/samples/SPEEDUP_AND_FADEOUT.EDL

@@ -1,11 +0,0 @@
-TITLE: SPEEDUP_AND_FADEOUT
-FCM: NON-DROP FRAME
-
-001  FOO      V     C        01:00:00:00 01:00:27:14 01:00:00:00 01:00:27:14  
-001        BL V     D    025 00:00:00:00 00:00:01:00 01:00:27:14 01:00:28:14  
-* EFFECT NAME: CROSS DISSOLVE
-* FROM CLIP NAME:  BARS_40S.MOV
-* COMMENT: 
-M2   FOO            035.0                01:00:00:00
-
-

data/test/samples/SPEEDUP_REVERSE_AND_FADEOUT.EDL

@@ -1,11 +0,0 @@
-TITLE: TESTREV
-FCM: NON-DROP FRAME
-
-001  FOO      V     C        01:00:39:23 01:01:07:12 01:00:00:00 01:00:27:14  
-001        BL V     D    025 00:00:00:00 00:00:01:00 01:00:27:14 01:00:28:14  
-* EFFECT NAME: CROSS DISSOLVE
-* FROM CLIP NAME:  BARS_40S.MOV
-* COMMENT: 
-M2   FOO           -035.0                01:00:39:23
-
-

data/test/samples/SPLICEME.EDL

@@ -1,5 +0,0 @@
-TITLE: SPLICEME
-FCM: NON-DROP FRAME
-
-001  006I     V     C        06:42:50:18 06:42:52:13 01:00:00:00 01:00:01:20  
-002  006I     V     C        06:42:52:14 06:42:52:16 01:00:10:21 01:00:10:23

data/test/samples/TIMEWARP.EDL

@@ -1,5 +0,0 @@
-TITLE: TIMEWARP_EDL
-FCM: NON-DROP FRAME
-
-001  003      V     C        03:03:19:19 03:03:20:04 01:00:04:03 01:00:04:13  
-M2   003            309.6                03:03:19:19

data/test/samples/TIMEWARP_HALF.EDL

@@ -1,5 +0,0 @@
-TITLE: TIMEWARP_HALF_EDL
-FCM: NON-DROP FRAME
-
-001  003      V     C        03:03:19:19 03:03:20:04 01:00:04:03 01:00:04:13  
-M2   003            12.5                03:03:19:19

data/test/samples/edl_mixed_line_endings.edl

@@ -1,12 +0,0 @@
-TITLE: EDL_TEST
-FCM: NON-DROP FRAME
-
-000001 A001C004_130917 V C 01:23:39:00 01:23:49:01 10:02:51:10 10:03:01:11
-* A
-* B
-* C
-* D
-* E
-* F
-* G
-

data/test/test_edl.rb

@@ -1,721 +0,0 @@
-require "rubygems"
-require "bundler"
-Bundler.require(:default, :development)
-require 'flexmock/test_unit'
-
-
-require File.dirname(__FILE__) + '/../lib/edl'
-require File.dirname(__FILE__) + '/../lib/edl/cutter'
-require File.dirname(__FILE__) + '/../lib/edl/grabber'
-
-TRAILER_EDL                 = File.dirname(__FILE__) + '/samples/TRAILER_EDL.edl'
-SIMPLE_DISSOLVE             = File.dirname(__FILE__) + '/samples/SIMPLE_DISSOLVE.EDL'
-SPLICEME                    = File.dirname(__FILE__) + '/samples/SPLICEME.EDL'
-SIMPLE_TIMEWARP             = File.dirname(__FILE__) + '/samples/TIMEWARP.EDL'
-SLOMO_TIMEWARP              = File.dirname(__FILE__) + '/samples/TIMEWARP_HALF.EDL'
-FORTY_FIVER                 = File.dirname(__FILE__) + '/samples/45S_SAMPLE.EDL'
-AVID_REVERSE                = File.dirname(__FILE__) + '/samples/REVERSE.EDL'
-SPEEDUP_AND_FADEOUT         = File.dirname(__FILE__) + '/samples/SPEEDUP_AND_FADEOUT.EDL'
-SPEEDUP_REVERSE_AND_FADEOUT = File.dirname(__FILE__) + '/samples/SPEEDUP_REVERSE_AND_FADEOUT.EDL'
-FCP_REVERSE                 = File.dirname(__FILE__) + '/samples/FCP_REVERSE.EDL'
-PLATES                      = File.dirname(__FILE__) + '/samples/PLATES.EDL'
-KEY                         = File.dirname(__FILE__) + '/samples/KEY_TRANSITION.EDL'
-CLIP_NAMES                  = File.dirname(__FILE__) + '/samples/REEL_IS_CLIP.txt'
-MIXED_LINEBREAKS            = File.dirname(__FILE__) + '/samples/edl_mixed_line_endings.edl'
-
-class String
-  def tc(fps = Timecode::DEFAULT_FPS)
-    Timecode.parse(self, fps)
-  end
-end
-
-class EDLTest < Test::Unit::TestCase
-  
-  def assert_zero(v, message = "Should be zero")
-    assert v.zero?, message
-  end
-  
-context "An Event" do
-  should "support hash initialization" do
-    evt = EDL::Event.new(:src_start_tc => "01:00:00:00".tc)
-    assert_equal "01:00:00:00".tc, evt.src_start_tc
-  end
-
-  should "support block initialization" do
-    evt = EDL::Event.new do | e | 
-      e.src_start_tc = "01:00:00:04".tc
-    end
-    assert_equal "01:00:00:04".tc, evt.src_start_tc 
-  end
-
-  should "respond to ends_with_transition? with false if outgoing_transition_duration is zero" do
-    evt = EDL::Event.new
-    evt.outgoing_transition_duration = 0
-    assert !evt.ends_with_transition?
-  end
-
-  should "respond to ends_with_transition? with true if outgoing_transition_duration set above zero" do
-    evt = EDL::Event.new
-    evt.outgoing_transition_duration = 24
-    assert evt.ends_with_transition?
-  end
-
-  should "respond to has_timewarp? with false if no timewarp assigned" do
-    evt = EDL::Event.new(:timewarp => nil)
-    assert !evt.has_timewarp?
-  end
-
-  should "respond to has_timewarp? with true if a timewarp  is assigned" do
-    evt = EDL::Event.new(:timewarp => true)
-    assert evt.has_timewarp?
-  end
-
-  should "report rec_length as a difference of record timecodes" do
-    evt = EDL::Event.new(:rec_start_tc => "1h".tc, :rec_end_tc => "1h 10s 2f".tc )
-    assert_equal "10s 2f".tc.to_i, evt.rec_length 
-  end
-
-  should "report rec_length_with_transition as a difference of record timecodes if no transition set" do
-    evt = EDL::Event.new(:rec_start_tc => "1h".tc, :rec_end_tc => "1h 10s 2f".tc, :outgoing_transition_duration => 0)
-    assert_equal "10s 2f".tc.to_i, evt.rec_length_with_transition
-  end
-
-  should "add transition length to rec_length_with_transition if a transition is set" do
-    evt = EDL::Event.new(:rec_start_tc => "1h".tc, :rec_end_tc => "1h 10s 2f".tc, :outgoing_transition_duration => 10)
-    assert_equal "10s 2f".tc.to_i + 10, evt.rec_length_with_transition
-  end
-
-  should "return a default array for comments" do
-    assert_kind_of Enumerable, EDL::Event.new.comments
-  end
-
-  should "respond false to has_transition? if incoming transition is set" do
-    assert !EDL::Event.new(:transition => nil).has_transition?
-  end
-
-  should "respond true to has_transition? if incoming transition is set" do
-    assert EDL::Event.new(:transition => true).has_transition?
-  end
-
-  should "respond true to black? if reel is BL" do
-    assert EDL::Event.new(:reel => "BL").black?
-    assert !EDL::Event.new(:reel => "001").black?
-  end
-
-  should "respond true to generator? if reel is BL or AX" do
-    assert EDL::Event.new(:reel => "BL").generator?
-    assert EDL::Event.new(:reel => "AX").generator?
-    assert !EDL::Event.new(:reel => "001").generator?
-  end
-
-  should "report src_length as rec_length_with_transition" do
-    e = EDL::Event.new(:rec_start_tc => "2h".tc,  :rec_end_tc => "2h 2s".tc)
-    assert_equal "2s".tc.to_i, e.src_length 
-  end
-
-  should "support line_number" do
-    assert_nil EDL::Event.new.line_number
-    assert_equal 3, EDL::Event.new(:line_number => 3).line_number
-  end
-
-  should "support capture_length as an alias to src_length" do
-    tw = flexmock
-    tw.should_receive(:actual_length_of_source).and_return(:something)
-    e = EDL::Event.new(:timewarp => tw)
-    assert_equal e.capture_length, e.src_length 
-  end
-
-  should "delegate src_length to the timewarp if it is there" do
-    tw = flexmock
-    tw.should_receive(:actual_length_of_source).and_return(:something).once
-    e = EDL::Event.new(:timewarp => tw)
-    assert_equal :something, e.src_length 
-  end
-
-  should "report reverse? and reversed? based on the timewarp" do
-    e = EDL::Event.new(:timewarp => nil)
-    assert !e.reverse?
-    assert !e.reversed?
-
-    tw = flexmock
-    tw.should_receive(:reverse?).and_return(true)
-
-    e = EDL::Event.new(:timewarp => tw)
-    assert e.reverse?
-    assert e.reversed?
-  end
-
-  should "report speed as 100 percent without a timewarp" do
-    e = EDL::Event.new
-    assert_equal 100.0, e.speed
-  end
-
-  should "consult the timewarp for speed" do
-    tw = flexmock
-    tw.should_receive(:speed).and_return(:something)
-
-    e = EDL::Event.new(:timewarp => tw)
-    assert_equal :something, e.speed
-  end
-
-  should "report false for starts_with_transition? if transision is nil" do
-    assert !EDL::Event.new.starts_with_transition?
-  end
-
-  should "report zero for incoming_transition_duration if transision is nil" do
-    assert_zero EDL::Event.new.incoming_transition_duration
-  end
-
-  should "report true for starts_with_transition? if transision is not nil" do
-    e = EDL::Event.new :transition => true
-    assert e.starts_with_transition?
-  end
-
-  should "consult the transition for incoming_transition_duration if it's present" do
-    tr = flexmock
-    tr.should_receive(:duration).and_return(:something)
-
-    e = EDL::Event.new(:transition => tr)
-    assert_equal :something, e.incoming_transition_duration
-  end
-
-  should "report capture_from_tc as the source start without a timewarp" do
-    e = EDL::Event.new(:src_start_tc => "1h".tc)
-    assert_equal "1h".tc, e.capture_from_tc
-  end
-
-  should "consult the timewarp for capture_from_tc if a timewarp is there" do
-    tw = flexmock
-    tw.should_receive(:source_used_from).and_return(:something)
-
-    e = EDL::Event.new(:timewarp => tw)
-    assert_equal :something, e.capture_from_tc
-  end
-
-  should "report capture_to_tc as record length plus transition when no timewarp present" do
-    e = EDL::Event.new(:src_end_tc => "1h 10s".tc, :outgoing_transition_duration => 2 )
-    assert_equal "1h 10s 2f".tc, e.capture_to_tc
-  end
-
-  should "report capture_to_and_including_tc as record length plus transition when no timewarp present" do
-    e = EDL::Event.new(:src_end_tc => "1h 10s".tc, :outgoing_transition_duration => 2 )
-    assert_equal "1h 10s 1f".tc, e.capture_to_and_including_tc
-  end
-
-  should "consult the timewarp for capture_to_tc if timewarp is present" do
-    tw = flexmock
-    tw.should_receive(:source_used_upto).and_return(:something)
-
-    e = EDL::Event.new(:timewarp => tw)
-    assert_equal :something, e.capture_to_tc
-  end
-end
-
-context "A Parser" do
-  should "store the passed framerate" do
-    p = EDL::Parser.new(45)
-    assert_equal 45, p.fps
-  end
-  
-  should "return matchers tuned with the passed framerate" do
-    p = EDL::Parser.new(30)
-    matchers = p.get_matchers
-    event_matcher = matchers.find{|e| e.is_a?(EDL::EventMatcher) }
-    assert_equal 30, event_matcher.fps
-  end
-  
-  should "create a Timecode from stringified elements" do
-    elems = ["08", "04", "24", "24"]
-    assert_nothing_raised do
-      @tc = EDL::Parser.timecode_from_line_elements(elems, 30)
-    end
-    
-    assert_kind_of Timecode, @tc
-    assert_equal "08:04:24:24".tc(30), @tc 
-    
-    assert_zero elems.length
-  end
-  
-  should "parse from a String" do
-    p = EDL::Parser.new
-    assert_nothing_raised do
-      @edl = p.parse File.read(SIMPLE_DISSOLVE)
-    end
-    
-    assert_kind_of EDL::List, @edl
-    assert_equal 2, @edl.length
-  end
-
-  should "parse from a File/IOish" do
-    p = EDL::Parser.new
-    assert_nothing_raised do
-      @edl = p.parse File.open(SIMPLE_DISSOLVE)
-    end
-    
-    assert_kind_of EDL::List, @edl
-    assert_equal 2, @edl.length
-  end
-    
-  should "properly parse a dissolve" do
-    # TODO: reformulate
-    p = EDL::Parser.new
-    @edl = p.parse File.open(SIMPLE_DISSOLVE)
-    
-    first, second = @edl
-    
-    assert_kind_of EDL::Event, first
-    assert_kind_of EDL::Event, second
-    
-    assert second.has_transition?
-    assert first.ends_with_transition?
-    assert !second.ends_with_transition?
-    
-    no_trans = @edl.without_transitions
-    
-    assert_equal 2, no_trans.length
-    target_tc = (Timecode.parse('01:00:00:00') + 43)
-    assert_equal target_tc, no_trans[0].rec_end_tc, 
-      "The incoming clip should have been extended by the length of the dissolve"
-    
-    target_tc = Timecode.parse('01:00:00:00')
-    assert_equal target_tc, no_trans[1].rec_start_tc
-      "The outgoing clip should have been left in place"
-  end
-  
-  should "return a spliced EDL if the sources allow" do
-    @spliced = EDL::Parser.new.parse(File.open(SPLICEME)).spliced
-    
-    assert_equal 1, @spliced.length
-    evt = @spliced[0]
-    
-    assert_equal '06:42:50:18'.tc, evt.src_start_tc
-    assert_equal '06:42:52:16'.tc, evt.src_end_tc
-  end
-  
-  should "not apply any Matchers if a match is found" do
-    p = EDL::Parser.new
-    m1 = flexmock
-    m1.should_receive(:matches?).with("plop").once.and_return(true)
-    m1.should_receive(:apply).once
-    
-    flexmock(p).should_receive(:get_matchers).once.and_return([m1, m1])
-    result = p.parse("plop")
-    assert result.empty?
-  end
-  
-  should "register line numbers of the detected events" do
-    p = EDL::Parser.new
-    events = p.parse(File.open(SPLICEME))
-    
-    assert_equal 4, events[0].line_number
-    assert_equal 5, events[1].line_number
-  end
-end
-
-context "A TimewarpMatcher" do
-  
-  should "not create any extra events when used within a Parser" do
-    @edl = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP))
-    assert_equal 1, @edl.length
-  end
-
-  should "properly describe a speedup" do
-    clip = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP)).pop
-    
-    tw = clip.timewarp
-    
-    assert_kind_of EDL::Timewarp, tw
-    assert_operator tw.source_used_upto, :>, clip.src_end_tc
-
-    assert_equal clip.src_start_tc, tw.source_used_from
-    assert_equal 124, clip.timewarp.actual_length_of_source
-    assert !tw.reverse?
-  end
-  
-  should "properly describe a slomo" do
-    clip = EDL::Parser.new.parse(File.open(SLOMO_TIMEWARP)).pop
-
-    assert_equal 10, clip.rec_length
-    assert_equal 5, clip.src_length
-    
-    tw = clip.timewarp
-    
-    assert_operator tw.source_used_upto, :<, clip.src_end_tc
-
-    assert_equal "03:03:19:24".tc, tw.source_used_upto
-    
-    assert_equal 50, tw.speed_in_percent.to_i
-    assert_equal 5, tw.actual_length_of_source
-    assert !tw.reverse?
-  end
-
-end
-
-context "A reverse timewarp EDL coming from Avid" do
-  
-  should "be parsed properly" do
-    
-    clip = EDL::Parser.new.parse(File.open(AVID_REVERSE)).pop
-    
-    assert_equal 52, clip.rec_length
-    
-    tw = clip.timewarp
-    
-    assert_equal -25, tw.actual_framerate.to_i
-    assert tw.reverse?
-    assert_equal 52, tw.actual_length_of_source
-    
-    assert_equal 52, clip.src_length, "The src length should be computed the same as its just a reverse"
-    assert_equal -100.0, clip.timewarp.speed
-  end
-end
-
-context "EDL with clip reels in comments" do
-  should "parse clip names into the reel field" do
-    clips = EDL::Parser.new.parse(File.open(CLIP_NAMES))
-    # flunk "This still has to be finalized"
-  end
-end
-
-context "A Final Cut Pro originating reverse" do
-  
-  should "be interpreted properly" do
-    e = EDL::Parser.new.parse(File.open(FCP_REVERSE)).pop
-    
-    assert_equal 1000, e.rec_length
-    assert_equal 1000, e.src_length
-
-    assert_equal "1h".tc, e.rec_start_tc 
-    assert_equal "1h 40s".tc, e.rec_end_tc
-    
-    assert e.reverse?
-    assert_not_nil e.timewarp
-    
-    tw = e.timewarp
-    
-    assert_equal -100, tw.speed
-    assert_equal e.speed, tw.speed
-    
-    assert_equal "1h".tc, tw.source_used_from 
-    assert_equal "1h 40s".tc, tw.source_used_upto
-  end
-end
-
-# context "An edit with keyer transition" do
-#   should "parse correctly" do
-#     events = EDL::Parser.new.parse(File.open(KEY))
-#     assert_equal 2, events.length
-#     flunk "Key transition processing is not reliable yet - no reference"
-#   end
-# end
-
-context "EventMatcher" do
-
-  EVT_PATTERNS = [
-    '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17', 
-    '021  009      V     C        00:39:04:21 00:39:05:09 01:00:26:17 01:00:27:05', 
-    '022  008C     V     C        08:08:01:23 08:08:02:18 01:00:27:05 01:00:28:00', 
-    '023  008C     V     C        08:07:30:02 08:07:30:21 01:00:28:00 01:00:28:19', 
-    '024        AX V     C        00:00:00:00 00:00:01:00 01:00:28:19 01:00:29:19', 
-    '025        BL V     C        00:00:00:00 00:00:00:00 01:00:29:19 01:00:29:19', 
-    '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20',
-    '002  REDACTED V     C        03:09:00:13 03:09:55:19 01:00:43:12 01:01:38:18',
-#    '0004 KASS1 A1234V C        00:00:00:00 00:00:16:06  10:00:41:08 10:00:57:14'
-  ]
-  
-#  should 'handle the event with multiple audio tracks' do
-#    m = EDL::EventMatcher.new(25)
-#    
-#    clip = m.apply([],
-#      '0004 KASS1 A1234V C        00:00:00:00 00:00:16:06  10:00:41:08 10:00:57:14'
-#    )
-#    assert_kind_of EDL::Event, clip
-#    assert_equal "A1234", clip.track
-#  end
-  
-  should "produce an Event" do
-    m = EDL::EventMatcher.new(25)
-    
-    clip = m.apply([],
-      '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17'
-    )
-    
-    assert_kind_of EDL::Event, clip
-    
-    assert_equal "020", clip.num
-    assert_equal "008C", clip.reel
-    assert_equal "V", clip.track
-    
-    assert_equal '08:04:24:24'.tc, clip.src_start_tc
-    
-    assert_equal '08:04:25:19'.tc, clip.src_end_tc 
-    assert_equal '01:00:25:22'.tc, clip.rec_start_tc 
-    assert_equal '01:00:26:17'.tc, clip.rec_end_tc   
-    
-    assert_nil clip.transition
-    assert_nil clip.timewarp
-    assert_zero clip.outgoing_transition_duration
-  end
-  
-  should "produce an Event with dissolve" do
-    m = EDL::EventMatcher.new(25)
-    
-    dissolve = m.apply([],
-      '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20'
-    )
-    assert_kind_of EDL::Event, dissolve
-    
-    assert_equal "025", dissolve.num
-    assert_equal 'GEN', dissolve.reel
-    assert_equal 'V', dissolve.track
-    assert dissolve.has_transition?
-    
-    tr = dissolve.transition
-    
-    assert_kind_of EDL::Dissolve, tr
-    assert_equal 25, tr.duration
-  end
-  
-  should "produce a vanilla Event with proper source length" do
-    # This one has EXACTLY 4 frames of source
-    m = EDL::EventMatcher.new(25)
-    clip = m.apply([], '001  GEN      V     C        00:01:00:00 00:01:00:04 01:00:00:00 01:00:00:04')
-    assert_kind_of EDL::Event, clip
-    assert_equal 4, clip.src_length
-  end
-  
-  should "set flag on the previous event in the stack when a dissolve is encountered" do
-    m = EDL::EventMatcher.new(25)
-    previous_evt = flexmock
-    previous_evt.should_receive(:outgoing_transition_duration=).with(25).once
-    
-    m.apply([previous_evt],
-      '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20'
-    )
-  end
-
-  should "generate a Wipe" do
-    m = EDL::EventMatcher.new(25)
-    wipe = m.apply([],
-      '025  GEN      V     W001  025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20'
-    )
-    
-    tr = wipe.transition
-    assert_kind_of EDL::Wipe, tr
-    assert_equal 25, tr.duration
-    assert_equal '001', tr.smpte_wipe_index
-  end
-  
-  EVT_PATTERNS.each do | pat |
-    should "match #{pat.inspect}" do
-      assert EDL::EventMatcher.new(25).matches?(pat)
-    end
-  end
-  
-  should "pass the framerate that it received upon instantiation to the Timecodes being created" do
-    
-    m = EDL::EventMatcher.new(30)
-    clip = m.apply([],
-      '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17'
-    )
-    assert_equal 30, clip.rec_start_tc.fps
-    assert_equal 30, clip.rec_end_tc.fps
-    assert_equal 30, clip.src_start_tc.fps
-    assert_equal 30, clip.src_end_tc.fps
-  end
-end
-
-context "CommentMatcher" do
-  should "match a comment" do
-    line = "* COMMENT: PURE BULLSHIT"
-    assert EDL::CommentMatcher.new.matches?(line)
-  end
-  
-  should "apply the comment to the last clip on the stack" do
-    line = "* COMMENT: PURE BULLSHIT"
-
-    comments = []
-    mok_evt = flexmock
-
-    2.times { mok_evt.should_receive(:comments).and_return(comments) }
-    2.times { EDL::CommentMatcher.new.apply([mok_evt], line) }
-
-    assert_equal ["* COMMENT: PURE BULLSHIT", "* COMMENT: PURE BULLSHIT"], mok_evt.comments
-  end
-end
-
-context "FallbackMatcher" do
-  should "match anything" do
-    line = "SOME"
-    assert EDL::FallbackMatcher.new.matches?(line)
-    
-    line = "OR ANOTHER  "
-    assert EDL::FallbackMatcher.new.matches?(line)
-  end
-  
-  should "not match whitespace" do
-    line = "\s\s\s\r\n\r"
-    assert !EDL::FallbackMatcher.new.matches?(line)
-  end
-  
-  should "append the matched content to comments" do
-    e = flexmock
-    cmts = []
-    e.should_receive(:comments).and_return(cmts)
-    
-    EDL::FallbackMatcher.new.apply([e], "FOOBAR")
-    assert_equal ["FOOBAR"], cmts
-
-    EDL::FallbackMatcher.new.apply([e], "FINAL CUT PRO REEL: 006-I REPLACED BY: 006I")
-    assert_equal ["FOOBAR", "FINAL CUT PRO REEL: 006-I REPLACED BY: 006I"], cmts
-  end
-  
-  should "raise an ApplyError if no clip is on the stack" do
-    assert_raise(EDL::Matcher::ApplyError) do
-     EDL::FallbackMatcher.new.apply([], "FINAL CUT PRO REEL: 006-I REPLACED BY: 006I")
-    end
-  end
-  
-end
-
-context "ClipNameMatcher" do
-  should "match a clip name" do
-    line = "* FROM CLIP NAME:  TAPE_6-10.MOV"
-    assert EDL::NameMatcher.new.matches?(line)
-  end
-  
-  should "match a clip name without space after star" do
-    line = "*FROM CLIP NAME:  TAPE_6-10.MOV"
-    assert EDL::NameMatcher.new.matches?(line)
-  end
-  
-  should "not match a simple comment" do
-    line = "* CRAP"
-    assert !EDL::NameMatcher.new.matches?(line)
-  end
-  
-  should "apply the name to the last event on the stack" do
-    line = "* FROM CLIP NAME:  TAPE_6-10.MOV"
-
-    mok_evt = flexmock
-    comments = []
-    mok_evt.should_receive(:clip_name=).with('TAPE_6-10.MOV').once
-    mok_evt.should_receive(:comments).and_return(comments).once
-    
-    EDL::NameMatcher.new.apply([mok_evt], line)
-    assert_equal ["* FROM CLIP NAME:  TAPE_6-10.MOV"], comments
-  end
-  
-end
-
-context "EffectMatcher" do
-  should "not match a simple comment" do
-    line = "* STUFF"
-    assert !EDL::EffectMatcher.new.matches?(line)
-  end
-
-  should "match a dissolve name" do
-    line = "* EFFECT NAME: CROSS DISSOLVE"
-    assert EDL::EffectMatcher.new.matches?(line)
-  end
-
-  should "match a dissolve name without space after the asterisk" do
-    line = "*EFFECT NAME: CROSS DISSOLVE"
-    assert EDL::EffectMatcher.new.matches?(line)
-  end
-
-  should "apply the effect name to the transition of the last event on the stack" do
-    line = "* EFFECT NAME: CROSS DISSOLVE"
-    mok_evt, mok_transition = flexmock, flexmock
-    cmt = []
-    
-    mok_evt.should_receive(:transition).once.and_return(mok_transition)
-    mok_evt.should_receive(:comments).once.and_return(cmt)
-
-    mok_transition.should_receive(:effect=).with("CROSS DISSOLVE").once
-    
-    EDL::EffectMatcher.new.apply([mok_evt], line)
-    
-    assert_equal ["* EFFECT NAME: CROSS DISSOLVE"], cmt
-  end
-
-end
-
-context "An EDL with mixed line breaks" do
-  should 'parse without errors' do
-    list = EDL::Parser.new.parse(File.open(MIXED_LINEBREAKS))
-    assert_equal ["* A", "* B", "* C", "* D", "* E", "* F", "* G"], list[0].comments
-  end
-end
-
-context "A complex EDL passed via Parser" do
-  should "parse without errors" do
-    assert_nothing_raised { EDL::Parser.new.parse(File.open(FORTY_FIVER)) }
-  end
-
-  should "parse the EDL with \\r line breaks properly" do
-    evts = EDL::Parser.new.parse(File.read(PLATES))
-    assert_equal 3, evts.length
-  end
-
-  # TODO: this does not belong here
-  should "be properly rewritten from zero" do
-    complex = EDL::Parser.new.parse(File.open(FORTY_FIVER))
-    from_zero = complex.from_zero
-  
-    assert_equal complex.length, from_zero.length, "Should have the same number of events"
-  
-    assert_zero from_zero[0].rec_start_tc
-    assert_equal '00:00:42:16'.tc, from_zero[-1].rec_end_tc 
-  end
-end
-
-context "A FinalCutPro speedup with fade at the end" do
-  should "be parsed cleanly" do
-    list = EDL::Parser.new.parse(File.open(SPEEDUP_AND_FADEOUT))
-  
-    assert_equal 2, list.length
-    
-    first_evt = list[0]
-  
-    tw = first_evt.timewarp
-    assert_kind_of EDL::Timewarp, tw
-  
-    assert_equal 689, first_evt.rec_length
-    assert_equal 714, first_evt.rec_length_with_transition
-    
-    assert_equal 1000, tw.actual_length_of_source
-    assert_equal 140, tw.speed
-    
-    assert_equal 1000, first_evt.src_length
-  
-    assert_equal "01:00:00:00", first_evt.capture_from_tc.to_s
-    assert_equal "01:00:40:00", first_evt.capture_to_tc.to_s
-  end
-end
-  
-context "In the trailer EDL the event 4" do
-  should "not have too many comments" do
-    evts = EDL::Parser.new.parse(File.open(TRAILER_EDL))
-    evt = evts[6]
-    assert_equal 5, evt.comments.length
-  end
-end
-
-context "A FinalCutPro speedup and reverse with fade at the end" do
-  should "parse cleanly" do
-    first_evt = EDL::Parser.new.parse(File.open(SPEEDUP_REVERSE_AND_FADEOUT)).shift
-
-    assert first_evt.reverse?
-    
-    assert_equal 689, first_evt.rec_length
-    assert_equal 714, first_evt.rec_length_with_transition
-    
-    tw = first_evt.timewarp
-    
-    assert_equal "1h 1f".tc, tw.source_used_from
-    assert_equal "1h 40s".tc, tw.source_used_upto
-  end
-end
-
-end