ruby-dtrace 0.0.1 → 0.0.2

data/test/test_dtrace.rb

@@ -97,126 +97,6 @@ class TestDtrace < Test::Unit::TestCase
     assert_equal 4, t.status # stopped
   end
 
-  def test_aggregate_print
-    t = Dtrace.new
-
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "syscall:::entry
-   			{
-                          @calls[execname] = count();
-			  @fcalls[probefunc] = count();
-			}"
-
-    prog = t.compile progtext
-    assert prog
-    prog.execute
-
-    t.go
-    sleep 1
-    t.stop
-
-    t.aggregate_snap
-    t.aggregate_print
-  end
-
-  def test_aggregate_walk
-    t = Dtrace.new
-
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "syscall:::entry
-   			{
-			  @fcalls[probefunc] = count();
-                          @calls[execname] = count();
-			}"
-
-    prog = t.compile progtext
-    assert prog
-    prog.execute
-
-    t.go
-    sleep 1
-    t.stop
-
-    t.aggregate_snap
-    
-    t.each_aggregate do |agg|
-      agg.each_record do |rec|
-        assert rec
-        assert rec.data
-      end
-    end
-  end
-
-  def test_aggregate_record_array
-    t = Dtrace.new
-
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "syscall:::entry
-   			{
-                          @calls[execname] = count();
-			}"
-
-    prog = t.compile progtext
-    assert prog
-    prog.execute
-
-    t.go
-    sleep 1
-    t.stop
-
-    t.aggregate_snap
-    
-    t.each_aggregate do |agg|
-      assert agg
-      assert agg.num_records
-      (0..(agg.num_records - 1)).each do |i|
-        rec = agg[i]
-        assert rec.data
-      end
-    end
-  end
-
-  def test_aggregate_record_array_continuous
-    t = Dtrace.new
-
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "syscall:::entry
-   			{
-                          @calls[execname] = count();
-			}"
-
-    prog = t.compile progtext
-    assert prog
-    prog.execute
-
-    t.go
-
-    (1..10).each do 
-      sleep 1
-      t.aggregate_snap
-      
-      t.each_aggregate do |agg|
-        assert agg
-        assert agg.num_records
-        (0..(agg.num_records - 1)).each do |i|
-          rec = agg[i]
-          assert rec.data
-        end
-      end
-      t.aggregate_clear
-    end
-
-    t.stop
-  end
-
   def test_bad_program
     t = Dtrace.new
     progtext = "blah blahb albhacasfas"
@@ -225,191 +105,5 @@ class TestDtrace < Test::Unit::TestCase
     end
     assert_equal "probe description :::blah does not match any probes", e.message
   end
-
-  def test_rubys_own_dtrace
-    t = Dtrace.new
-
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "ruby*:::function-entry{ @[copyinstr(arg1)] = count(); }"
-
-    prog = t.compile progtext
-    assert prog
-    prog.execute
-
-    t.go
-
-    foo = 0
-    (1..1000).each do |i|
-      foo = foo + i
-    end
-    
-    t.stop
-    t.aggregate_snap
-    
-    t.each_aggregate do |agg|
-      assert agg
-      assert agg.num_records
-      (0..(agg.num_records - 1)).each do |i|
-        rec = agg[i]
-        assert rec.data
-      end
-    end
-  end
-
-  def test_multiple_programs
-    t = Dtrace.new
-
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "syscall:::entry
-   		{
-                    @calls[execname] = count();
-                }"
-
-    prog1 = t.compile progtext
-    assert prog1
-
-    progtext = "syscall:::entry
-   		{
-			  @fcalls[probefunc] = count();
-                }"
-
-    prog2 = t.compile progtext
-    assert prog2
-
-    prog1.execute
-    prog2.execute
-
-    info1 = prog1.info
-    assert info1
-    assert_equal 1,   info1.aggregates_count
-    assert_equal 0,   info1.speculations_count
-    assert_equal 2,   info1.recgens_count
-    assert            info1.matches_count
-
-    info2 = prog2.info
-    assert info2
-    assert_equal 1,   info2.aggregates_count
-    assert_equal 0,   info2.speculations_count
-    assert_equal 2,   info2.recgens_count
-    assert            info2.matches_count
-
-    t.go
-    sleep 2
-    t.stop
-    t.aggregate_snap
-    
-    t.each_aggregate do |agg|
-      assert agg
-      assert agg.num_records
-      (0..(agg.num_records - 1)).each do |i|
-        rec = agg[i]
-        assert rec.data
-      end
-    end
-  end
-
-  def test_multiple_runs
-    t = Dtrace.new
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "ruby*:::function-entry{ @[copyinstr(arg1)] = count(); }"
-
-    prog = t.compile progtext
-    assert prog
-    prog.execute
-
-    t.go
-
-    foo = 0
-    (1..1000).each do |i|
-      foo = foo + i
-    end
-    
-    t.stop
-    t.aggregate_snap
-    
-    t.each_aggregate do |agg|
-      assert agg
-      assert agg.num_records
-      (0..(agg.num_records - 1)).each do |i|
-        rec = agg[i]
-        assert rec.data
-      end
-    end
-
-    t = Dtrace.new
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    prog = t.compile progtext
-    assert prog
-
-    prog.execute
-
-    t.go
-
-    foo = 0
-    (1..1000).each do |i|
-      foo = foo + i
-    end
-    
-    t.stop
-    t.aggregate_snap
-    
-    t.each_aggregate do |agg|
-      assert agg
-      assert agg.num_records
-      (0..(agg.num_records - 1)).each do |i|
-        rec = agg[i]
-        assert rec.data
-      end
-    end
-
-  end
-
-  def test_aggdata_probe
-    t = Dtrace.new
-
-    t.setopt("aggsize", "4m")
-    t.setopt("bufsize", "4m")
-
-    progtext = "ruby*:::function-entry{ @[copyinstr(arg1)] = count(); }"
-
-    prog = t.compile progtext
-    assert prog
-    prog.execute
-
-    t.go
-
-    foo = 0
-    (1..1000).each do |i|
-      foo = foo + i
-    end
-
-    t.stop
-
-    t.aggregate_snap
-    
-    t.each_aggregate do |agg|
-
-      probe = agg.probe
-      assert probe.provider
-      assert probe.mod
-      assert probe.func
-      assert probe.name
-      
-      agg.each_record do |rec|
-        assert rec
-        assert rec.data
-      end
-    end
-
-
-  end
   
 end

data/test/test_dtrace_workapi.rb

@@ -0,0 +1,142 @@
+require 'dtrace'
+require 'test/unit'
+
+class TestDtrace < Test::Unit::TestCase
+  def test_dtrace
+    t = Dtrace.new
+    assert t
+    assert_equal Object, Dtrace.superclass
+    assert_equal Dtrace, t.class
+  end
+
+  def test_work_dprogram_compile
+    t = Dtrace.new 
+    assert t
+
+    progtext = "syscall::select:entry { trace(probefunc); trace(execname); }"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    info = prog.info
+    assert info
+    assert_equal 1, info.matches_count
+  end
+
+  def test_work_dprogram_run
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext = "syscall:::entry { trace(probefunc); trace(execname); }"
+    
+    prog = t.compile progtext
+    prog.execute
+
+    c = DtraceConsumer.new(t)
+    assert c
+
+    begin
+      i = 0
+      c.consume do |e|
+        assert e
+        assert e.probedesc
+        assert_equal 'syscall', e.probedesc.provider
+        assert_equal 'entry', e.probedesc.name
+        records = e.records
+        assert records
+        assert_equal 2, records.length
+        assert_equal DtraceRecord, records[0].class
+        assert_equal DtraceRecord, records[1].class
+
+        i = i + 1
+        if i > 10
+          break
+        end
+      end
+    rescue Interrupt
+      puts "interrupted"
+    end
+  end
+
+  def test_work_dprogram_aggregates
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext = <<EOD
+ruby*:::function-entry
+{ 
+  @a[execname, copyinstr(arg1), copyinstr(arg2)] = count(); 
+  printf("foo");
+}
+
+profile-10
+{
+  printa(@a)
+}
+EOD
+
+    prog = t.compile progtext
+    prog.execute
+    
+    c = DtraceConsumer.new(t)
+
+    begin
+      i = 0
+      c.consume do |e|
+        assert e
+        case e.class.to_s
+        when "DtraceProbeData"
+          assert e.probedesc
+          e.each_record do |r|
+            assert r.value
+          end
+        when "DtraceRecord"
+          assert e.value
+        when "DtraceAggregate"
+          assert e.value
+          assert e.tuple
+          assert_equal 3, e.tuple.length
+        end
+          
+        i = i + 1
+        if i > 100
+          break
+        end
+      end
+    rescue Interrupt
+      puts "interrupted"
+    end
+   
+  end
+
+  def test_work_dprogram_once
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+    
+    progtext = "ruby*:::function-entry{ @a[execname, copyinstr(arg1), copyinstr(arg2)] = count(); } END { printa(@a); }"
+
+    prog = t.compile progtext
+    prog.execute
+
+    t.go
+
+    foo = 0
+    (1..1000).each do |i|
+      foo = foo + i
+    end
+    
+    c = DtraceConsumer.new(t)
+    c.consume_once do |e|
+      if e && e.class == DtraceAggregate
+        assert e.value
+        assert e.tuple
+        assert_equal 3, e.tuple.length
+      end
+    end
+  end
+  
+end