dtas 0.0.0

data/test/covshow.rb

@@ -0,0 +1,30 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# this works with the __covmerge method in test/helper.rb
+# run this file after all tests are run
+
+# load the merged dump data
+res = Marshal.load(IO.binread("coverage.dump"))
+
+# Dirty little text formatter.  I tried simplecov but the default
+# HTML+JS is unusable without a GUI (I hate GUIs :P) and it would've
+# taken me longer to search the Internets to find a plain-text
+# formatter I like...
+res.keys.sort.each do |filename|
+  cov = res[filename]
+  puts "==> #{filename} <=="
+  File.readlines(filename).each_with_index do |line, i|
+    n = cov[i]
+    if n == 0 # BAD
+      print("  *** 0 #{line}")
+    elsif n
+      printf("% 7u %s", n, line)
+    elsif line =~ /\S/ # probably a line with just "end" in it
+      print("        #{line}")
+    else # blank line
+      print "\n" # don't output trailing whitespace on blank lines
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,76 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+$stdout.sync = $stderr.sync = Thread.abort_on_exception = true
+
+# fork-aware coverage data gatherer, see also test/covshow.rb
+if ENV["COVERAGE"]
+  require "coverage"
+  COVMATCH = %r{/lib/dtas\b.*rb\z}
+  COVTMP = File.open("coverage.dump", IO::CREAT|IO::RDWR)
+  COVTMP.binmode
+  COVTMP.sync = true
+
+  def __covmerge
+    res = Coverage.result
+
+    # we own this file (at least until somebody tries to use NFS :x)
+    COVTMP.flock(File::LOCK_EX)
+
+    COVTMP.rewind
+    prev = COVTMP.read
+    prev = prev.empty? ? {} : Marshal.load(prev)
+    res.each do |filename, counts|
+      # filter out stuff that's not in our project
+      COVMATCH =~ filename or next
+
+      merge = prev[filename] || []
+      merge = merge
+      counts.each_with_index do |count, i|
+        count or next
+        merge[i] = (merge[i] || 0) + count
+      end
+      prev[filename] = merge
+    end
+    COVTMP.rewind
+    COVTMP.truncate(0)
+    COVTMP.write(Marshal.dump(prev))
+  ensure
+    COVTMP.flock(File::LOCK_UN)
+  end
+
+  Coverage.start
+  at_exit { __covmerge }
+end
+
+gem 'minitest'
+require 'minitest/autorun'
+require "tempfile"
+
+FIFOS = []
+at_exit { FIFOS.each { |(pid,path)| File.unlink(path) if $$ == pid } }
+def tmpfifo
+  tmp = Tempfile.new(%w(dtas-test .fifo))
+  path = tmp.path
+  tmp.close!
+  assert system(*%W(mkfifo #{path})), "mkfifo #{path}"
+  FIFOS << [ $$, path ]
+  path
+end
+
+require 'tmpdir'
+class Dir
+  require 'fileutils'
+  def Dir.mktmpdir
+    begin
+      d = "#{Dir.tmpdir}/#$$.#{rand}"
+      Dir.mkdir(d)
+    rescue Errno::EEXIST
+    end while true
+    begin
+      yield d
+    ensure
+      FileUtils.remove_entry(d)
+    end
+  end
+end unless Dir.respond_to?(:mktmpdir)

data/test/player_integration.rb

@@ -0,0 +1,121 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/helper'
+require 'dtas/player'
+require 'dtas/state_file'
+require 'yaml'
+require 'tempfile'
+require 'shellwords'
+require 'timeout'
+
+module PlayerIntegration
+  def setup
+    sock_tmp = Tempfile.new(%w(dtas-test .sock))
+    @state_tmp = Tempfile.new(%w(dtas-test .yml))
+    @sock_path = sock_tmp.path
+    sock_tmp.close!
+    @player = DTAS::Player.new
+    @player.socket = @sock_path
+    @player.state_file = DTAS::StateFile.new(@state_tmp.path)
+    @player.bind
+    @out = Tempfile.new(%w(dtas-test .out))
+    @err = Tempfile.new(%w(dtas-test .err))
+    @out.sync = @err.sync = true
+    @pid = fork do
+      at_exit { @player.close }
+      ENV["SOX_OPTS"] = "#{ENV['SOX_OPTS']} -R"
+      unless $DEBUG
+        $stdout.reopen(@out)
+        $stderr.reopen(@err)
+      end
+      @player.run
+    end
+
+    # null playback device with delay to simulate a real device
+    @fmt = DTAS::Format.new
+    @period = 0.01
+    @period_size = @fmt.bytes_per_sample * @fmt.channels * @fmt.rate * @period
+    @cmd = "exec 2>/dev/null " \
+           "ruby -e " \
+           "\"b=%q();loop{STDIN.readpartial(#@period_size,b);sleep(#@period)}\""
+
+    # FIXME gross...
+    @player.instance_eval do
+      @sink_buf.close!
+    end
+  end
+
+  module PlayerClient
+    def preq(args)
+      args = Shellwords.join(args) if Array === args
+      send(args, Socket::MSG_EOR)
+    end
+  end
+
+  def client_socket
+    s = Socket.new(:AF_UNIX, :SOCK_SEQPACKET, 0)
+    s.connect(Socket.pack_sockaddr_un(@sock_path))
+    s.extend(PlayerClient)
+    s
+  end
+
+  def wait_pid_dead(pid, time = 5)
+    Timeout.timeout(time) do
+      begin
+        Process.kill(0, pid)
+        sleep(0.01)
+      rescue Errno::ESRCH
+        return
+      end while true
+    end
+  end
+
+  def wait_files_not_empty(*files)
+    files = Array(files)
+    Timeout.timeout(5) { sleep(0.01) until files.all? { |f| f.size > 0 } }
+  end
+
+  def default_sink_pid(s)
+    default_pid = Tempfile.new(%w(dtas-test .pid))
+    pf = "echo $$ >> #{default_pid.path}; "
+    s.send("sink ed default command='#{pf}#@cmd'", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    default_pid
+  end
+
+  def teardown
+    Process.kill(:TERM, @pid) if @pid
+    Process.waitall
+    refute File.exist?(@sock_path)
+    @state_tmp.close!
+    @out.close! if @out
+    @err.close! if @err
+  end
+
+  def read_pid_file(file)
+    file.rewind
+    pid = file.read.to_i
+    assert_operator pid, :>, 0
+    pid
+  end
+
+  def tmp_noise(len = 5)
+    noise = Tempfile.open(%w(junk .sox))
+    cmd = %W(sox -R -n -r44100 -c2 #{noise.path} synth #{len} pluck)
+    assert system(*cmd), cmd
+    [ noise, len ]
+  end
+
+  def dethrottle_decoder(s)
+    s.send("sink ed default active=false", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+  end
+
+  def stop_playback(pid_file, s)
+    s.send("skip", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    pid = read_pid_file(pid_file)
+    wait_pid_dead(pid)
+  end
+end

data/test/test_buffer.rb

@@ -0,0 +1,216 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/helper'
+require 'stringio'
+require 'dtas/buffer'
+
+class TestBuffer < Minitest::Unit::TestCase
+  def teardown
+    @to_close.each { |io| io.close unless io.closed? }
+  end
+
+  def setup
+    @to_close = []
+  end
+
+  def pipe
+    ret = IO.pipe
+    @to_close.concat(ret)
+    ret
+  end
+
+  def tmperr
+    olderr = $stderr
+    $stderr = newerr = StringIO.new
+    yield
+    newerr
+  ensure
+    $stderr = olderr
+  end
+
+  def new_buffer
+    buf = DTAS::Buffer.new
+    @to_close << buf.to_io
+    @to_close << buf.wr
+    buf
+  end
+
+  def test_set_buffer_size
+    buf = new_buffer
+    buf.buffer_size = DTAS::Buffer::MAX_SIZE
+    assert_equal DTAS::Buffer::MAX_SIZE, buf.buffer_size
+  end if defined?(DTAS::Buffer::MAX_SIZE)
+
+  def test_buffer_size
+    buf = new_buffer
+    assert_operator buf.buffer_size, :>, 128
+    buf.buffer_size = DTAS::Buffer::MAX_SIZE
+    assert_equal DTAS::Buffer::MAX_SIZE, buf.buffer_size
+  end if defined?(DTAS::Buffer::MAX_SIZE)
+
+  def test_broadcast_1
+    buf = new_buffer
+    r, w = IO.pipe
+    assert_equal :wait_readable, buf.broadcast([w])
+    assert_equal 0, buf.bytes_xfer
+    buf.wr.write "HIHI"
+    assert_equal :wait_readable, buf.broadcast([w])
+    assert_equal 4, buf.bytes_xfer
+    assert_equal :wait_readable, buf.broadcast([w])
+    assert_equal 4, buf.bytes_xfer
+    tmp = [w]
+    r.close
+    buf.wr.write "HIHI"
+    newerr = tmperr { assert_nil buf.broadcast(tmp) }
+    assert_equal [], tmp
+    assert_match(%r{dropping}, newerr.string)
+  end
+
+  def test_broadcast_tee
+    buf = new_buffer
+    return unless buf.respond_to?(:__broadcast_tee)
+    blocked = []
+    a = pipe
+    b = pipe
+    buf.wr.write "HELLO"
+    assert_equal 4, buf.__broadcast_tee(blocked, [a[1], b[1]], 4)
+    assert_empty blocked
+    assert_equal "HELL", a[0].read(4)
+    assert_equal "HELL", b[0].read(4)
+    assert_equal 5, buf.__broadcast_tee(blocked, [a[1], b[1]], 5)
+    assert_empty blocked
+    assert_equal "HELLO", a[0].read(5)
+    assert_equal "HELLO", b[0].read(5)
+    max = '*' * a[0].pipe_size
+    assert_equal max.size, a[1].write(max)
+    assert_equal a[0].nread, a[0].pipe_size
+    a[1].nonblock = true
+    assert_equal 5, buf.__broadcast_tee(blocked, [a[1], b[1]], 5)
+    assert_equal [a[1]], blocked
+    a[1].nonblock = false
+    b[0].read(b[0].nread)
+    b[1].write(max)
+    t = Thread.new do
+      sleep 0.005
+      [ a[0].read(max.size).size, b[0].read(max.size).size ]
+    end
+    assert_equal 5, buf.__broadcast_tee(blocked, [a[1], b[1]], 5)
+    assert_equal [a[1]], blocked
+    assert_equal [ max.size, max.size ], t.value
+    b[0].close
+    tmp = [a[1], b[1]]
+
+    newerr = tmperr { assert_equal 5, buf.__broadcast_tee(blocked, tmp, 5) }
+    assert_equal [a[1]], blocked
+    assert_match(%r{dropping}, newerr.string)
+    assert_equal [a[1]], tmp
+  end
+
+  def test_broadcast
+    a = pipe
+    b = pipe
+    buf = new_buffer
+    buf.wr.write "HELLO"
+    assert_equal :wait_readable, buf.broadcast([a[1], b[1]])
+    assert_equal 5, buf.bytes_xfer
+    assert_equal "HELLO", a[0].read(5)
+    assert_equal "HELLO", b[0].read(5)
+    assert_equal :wait_readable, buf.broadcast([a[1], b[1]])
+    assert_equal 5, buf.bytes_xfer
+
+    b[1].nonblock = true
+    b[1].write('*' * b[1].pipe_size)
+    buf.wr.write "BYE"
+    assert_equal :wait_readable, buf.broadcast([a[1], b[1]])
+    assert_equal 8, buf.bytes_xfer
+
+    buf.wr.write "DROP"
+    b[0].close
+    tmp = [a[1], b[1]]
+    newerr = tmperr { assert_equal :wait_readable, buf.broadcast(tmp) }
+    assert_equal 12, buf.bytes_xfer
+    assert_equal [a[1]], tmp
+    assert_match(%r{dropping}, newerr.string)
+  end
+
+  def test_broadcast_total_fail
+    a = pipe
+    b = pipe
+    buf = new_buffer
+    buf.wr.write "HELLO"
+    a[0].close
+    b[0].close
+    tmp = [a[1], b[1]]
+    newerr = tmperr { assert_nil buf.broadcast(tmp) }
+    assert_equal [], tmp
+    assert_match(%r{dropping}, newerr.string)
+  end
+
+  def test_broadcast_mostly_fail
+    a = pipe
+    b = pipe
+    c = pipe
+    buf = new_buffer
+    buf.wr.write "HELLO"
+    b[0].close
+    c[0].close
+    tmp = [a[1], b[1], c[1]]
+    newerr = tmperr { assert_equal :wait_readable, buf.broadcast(tmp) }
+    assert_equal 5, buf.bytes_xfer
+    assert_equal [a[1]], tmp
+    assert_match(%r{dropping}, newerr.string)
+  end
+
+  def test_broadcast_all_full
+    a = pipe
+    b = pipe
+    buf = new_buffer
+    a[1].write('*' * a[1].pipe_size)
+    b[1].write('*' * b[1].pipe_size)
+
+    a[1].nonblock = true
+    b[1].nonblock = true
+    tmp = [a[1], b[1]]
+
+    buf.wr.write "HELLO"
+    assert_equal tmp, buf.broadcast(tmp)
+    assert_equal [a[1], b[1]], tmp
+  end
+
+  def test_serialize
+    buf = new_buffer
+    hash = buf.to_hsh
+    assert_empty hash
+    buf.buffer_size = 4096
+    hash = buf.to_hsh
+    assert_equal %w(buffer_size), hash.keys
+    assert_kind_of Integer, hash["buffer_size"]
+    assert_operator hash["buffer_size"], :>, 0
+  end
+
+  def test_close
+    buf = DTAS::Buffer.new
+    buf.wr.write "HI"
+    assert_equal 2, buf.inflight
+    buf.close
+    assert_equal 0, buf.inflight
+    assert_nil buf.close!
+  end
+
+  def test_load_nil
+    buf = DTAS::Buffer.load(nil)
+    buf.close!
+  end
+
+  def test_load_empty
+    buf = DTAS::Buffer.load({})
+    buf.close!
+  end
+
+  def test_load_size
+    buf = DTAS::Buffer.load({"buffer_size" => 4096})
+    assert_equal 4096, buf.buffer_size
+    buf.close!
+  end
+end

data/test/test_format.rb

@@ -0,0 +1,61 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/helper'
+require 'tempfile'
+require 'dtas/format'
+
+class TestFormat < Minitest::Unit::TestCase
+  def test_initialize
+    fmt = DTAS::Format.new
+    assert_equal %w(-ts32 -c2 -r44100), fmt.to_sox_arg
+    hash = fmt.to_hsh
+    assert_equal({}, hash)
+  end
+
+  def test_nonstandard
+    fmt = DTAS::Format.new
+    fmt.type = "s16"
+    fmt.rate = 48000
+    fmt.channels = 4
+    hash = fmt.to_hsh
+    assert_kind_of Hash, hash
+    assert_equal %w(channels rate type), hash.keys.sort
+    assert_equal "s16", hash["type"]
+    assert_equal 48000, hash["rate"]
+    assert_equal 4, hash["channels"]
+
+    # back to stereo
+    fmt.channels = 2
+    hash = fmt.to_hsh
+    assert_equal %w(rate type), hash.keys.sort
+    assert_equal "s16", hash["type"]
+    assert_equal 48000, hash["rate"]
+    assert_nil hash["channels"]
+  end
+
+  def test_from_file
+    Tempfile.open(%w(tmp .wav)) do |tmp|
+      # generate an empty file with 1s of audio
+      cmd = %W(sox -r 96000 -b 24 -c 2 -n #{tmp.path} trim 0 1)
+      system(*cmd)
+      assert $?.success?, "#{cmd.inspect} failed: #$?"
+      fmt = DTAS::Format.new
+      fmt.from_file tmp.path
+      assert_equal 96000, fmt.rate
+      assert_equal 2, fmt.channels
+      tmp.unlink
+    end
+  end
+
+  def test_bytes_per_sample
+    fmt = DTAS::Format.new
+    assert_equal 4, fmt.bytes_per_sample
+    fmt.type = "f64"
+    assert_equal 8, fmt.bytes_per_sample
+    fmt.type = "f32"
+    assert_equal 4, fmt.bytes_per_sample
+    fmt.type = "s16"
+    assert_equal 2, fmt.bytes_per_sample
+  end
+end