bmff 0.0.1

data/test/bmff/box/test_composition_to_decode.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxCompositionToDecode < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("cslg")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_int32(1) # composition_to_dts_shift
+    io.write_int32(2) # least_decode_to_display_delta
+    io.write_int32(3) # greatest_decode_to_display_delta
+    io.write_int32(4) # composition_start_time
+    io.write_int32(5) # composition_end_time
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::CompositionToDecode, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("cslg", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.composition_to_dts_shift)
+    assert_equal(2, box.least_decode_to_display_delta)
+    assert_equal(3, box.greatest_decode_to_display_delta)
+    assert_equal(4, box.composition_start_time)
+    assert_equal(5, box.composition_end_time)
+  end
+end

data/test/bmff/box/test_copyright.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxCopyright < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("cprt")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_byte("\x15\xC7") # language (eng)
+    io.write_null_terminated_string("Copyright (c)") # notice
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::Copyright, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("cprt", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal("eng", box.language)
+    assert_equal("Copyright (c)", box.notice)
+  end
+
+  def test_parse_without_notice
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("cprt")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_byte("\x2A\x0E") # language (jpn)
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::Copyright, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("cprt", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal("jpn", box.language)
+    assert_nil(box.notice)
+  end
+end

data/test/bmff/box/test_data_entry_url.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxDataEntryUrl < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("url ")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_null_terminated_string("http://example.com/") # location
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::DataEntryUrl, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("url ", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal("http://example.com/", box.location)
+  end
+end

data/test/bmff/box/test_data_entry_urn.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxDataEntryUrn < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("urn ")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_null_terminated_string("bmff") # name
+    io.write_null_terminated_string("urn:example") # location
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::DataEntryUrn, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("urn ", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal("bmff", box.name)
+    assert_equal("urn:example", box.location)
+  end
+end

data/test/bmff/box/test_data_information.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxDataInformation < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("dinf")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::DataInformation, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("dinf", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_data_reference.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxDataReference < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("dref")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(2) # entry_count
+    # DataEntryUrn
+    io.write_uint32(29) # size
+    io.write_ascii("urn ") # type
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_null_terminated_string("bmff") # name
+    io.write_null_terminated_string("urn:example") # location
+    # DataEntryUrl
+    io.write_uint32(32) # size
+    io.write_ascii("url ") # type
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_null_terminated_string("http://example.com/") # location
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::DataReference, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("dref", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(2, box.entry_count)
+
+    assert_instance_of(BMFF::Box::DataEntryUrn, box.children[0])
+    assert_equal(29, box.children[0].actual_size)
+    assert_equal("urn ", box.children[0].type)
+    assert_equal(0, box.children[0].version)
+    assert_equal(0, box.children[0].flags)
+    assert_equal("bmff", box.children[0].name)
+    assert_equal("urn:example", box.children[0].location)
+
+    assert_instance_of(BMFF::Box::DataEntryUrl, box.children[1])
+    assert_equal(32, box.children[1].actual_size)
+    assert_equal("url ", box.children[1].type)
+    assert_equal(0, box.children[1].version)
+    assert_equal(0, box.children[1].flags)
+    assert_equal("http://example.com/", box.children[1].location)
+  end
+end

data/test/bmff/box/test_degradation_priority.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxDegradationPriority < MiniTest::Unit::TestCase
+  class DummyBox
+    attr_accessor :box
+    def find(type)
+      @box
+    end
+  end
+
+  def get_sample_size(count = 1)
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stsz")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(0) # sample_size
+    io.write_uint32(count) # sample_count
+    count.times do |i|
+      io.write_uint32(i) # entry_size
+    end
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    dummy = DummyBox.new
+    dummy.box = box
+    dummy
+  end
+
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stdp")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint16(1) # priority
+    io.write_uint16(2) # priority
+    io.write_uint16(3) # priority
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, get_sample_size(3))
+    assert_instance_of(BMFF::Box::DegradationPriority, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stdp", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal([1, 2, 3], box.priority)
+  end
+end

data/test/bmff/box/test_edit.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxEdit < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("edts")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::Edit, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("edts", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_edit_list.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxEditList < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("elst")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    3.times do |i|
+      io.write_uint32(10 + i) # segment_duration
+      io.write_int32(20 + i) # media_time
+      io.write_int16(i) # media_rate_integer
+      io.write_int16(0) # media_rate_fraction
+    end
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::EditList, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("elst", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([10, 11, 12], box.segment_duration)
+    assert_equal([20, 21, 22], box.media_time)
+    assert_equal([0, 1, 2], box.media_rate_integer)
+    assert_equal([0, 0, 0], box.media_rate_fraction)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("elst")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    3.times do |i|
+      io.write_uint64(10 + i) # segment_duration
+      io.write_int64(20 + i) # media_time
+      io.write_int16(i) # media_rate_integer
+      io.write_int16(0) # media_rate_fraction
+    end
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::EditList, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("elst", box.type)
+    assert_equal(1, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([10, 11, 12], box.segment_duration)
+    assert_equal([20, 21, 22], box.media_time)
+    assert_equal([0, 1, 2], box.media_rate_integer)
+    assert_equal([0, 0, 0], box.media_rate_fraction)
+  end
+end

data/test/bmff/box/test_file_type.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxFileType < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("ftyp")
+    io.write_ascii("isml") # major_brand
+    io.write_uint32(1) # minor_version
+    io.write_ascii("piffiso2iso6") # compatible_brands
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::FileType, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("ftyp", box.type)
+    assert_equal("isml", box.major_brand)
+    assert_equal(1, box.minor_version)
+    assert_equal(%w(piff iso2 iso6), box.compatible_brands)
+  end
+end

data/test/bmff/box/test_free_space.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxFreeSpace < MiniTest::Unit::TestCase
+  def test_parse_free
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("free")
+    io.write_byte("abcdefg") # data
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::FreeSpace, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("free", box.type)
+  end
+
+  def test_parse_skip
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("skip")
+    io.write_byte("abcdefg") # data
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::FreeSpace, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("skip", box.type)
+  end
+end

data/test/bmff/box/test_handler.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxHandler < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("hdlr")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(0) # pre_defined
+    io.write_ascii("vide") # handler_type
+    io.write_uint32(0) # reserved1
+    io.write_uint32(0) # reserved1
+    io.write_uint32(0) # reserved1
+    io.write_null_terminated_string("bmff test") # name
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::Handler, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("hdlr", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(0, box.pre_defined)
+    assert_equal("vide", box.handler_type)
+    assert_equal([0, 0, 0], box.reserved1)
+    assert_equal("bmff test", box.name)
+  end
+
+  def test_parse_without_name
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("hdlr")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(0) # pre_defined
+    io.write_ascii("vide") # handler_type
+    io.write_uint32(0) # reserved1
+    io.write_uint32(0) # reserved1
+    io.write_uint32(0) # reserved1
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::Handler, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("hdlr", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(0, box.pre_defined)
+    assert_equal("vide", box.handler_type)
+    assert_equal([0, 0, 0], box.reserved1)
+    assert_nil(box.name)
+  end
+end

data/test/bmff/box/test_hint_media_header.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxHintMediaHeader < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("hmhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint16(10) # max_pdu_size
+    io.write_uint16(5) # avg_pdu_size
+    io.write_uint32(1000000) # maxbitrate
+    io.write_uint32(500000) # avgbitrate
+    io.write_uint32(0) # reserved1
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::HintMediaHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("hmhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(10, box.max_pdu_size)
+    assert_equal(5, box.avg_pdu_size)
+    assert_equal(1000000, box.maxbitrate)
+    assert_equal(500000, box.avgbitrate)
+    assert_equal(0, box.reserved1)
+  end
+end

data/test/bmff/box/test_hint_sample_entry.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxHintSampleEntry < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("hint")
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint16(1) # data_reference_index
+    io.write_uint8(0) # data
+    io.write_uint8(1) # data
+    io.write_uint8(2) # data
+    io.write_uint8(3) # data
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil, BMFF::Box::HintSampleEntry)
+    assert_instance_of(BMFF::Box::HintSampleEntry, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("hint", box.type)
+    assert_equal([0, 0, 0, 0, 0, 0], box.reserved1)
+    assert_equal(1, box.data_reference_index)
+    assert_equal([0, 1, 2, 3], box.data)
+  end
+end

data/test/bmff/box/test_level_assignment.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxLevelAssignment < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("leva")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint8(5) # level_count
+    5.times do |i|
+      io.write_uint32(i) # track_id
+      io.write_uint8(i) # padding_flag, assignment_type
+      case i
+      when 0
+        io.write_uint32(10 + i) # grouping_type
+      when 1
+        io.write_uint32(10 + i) # grouping_type
+        io.write_uint32(20 + i) # grouping_type_parameter
+      when 4
+        io.write_uint32(30 + i) # sub_track_id
+      end
+    end
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::LevelAssignment, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("leva", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(5, box.level_count)
+    assert_equal(5, box.levels.count)
+    assert_equal([0, 1, 2, 3, 4], box.levels.map{|e| e.track_id})
+    assert_equal([0, 0, 0, 0, 0], box.levels.map{|e| e.padding_flag})
+    assert_equal([0, 1, 2, 3, 4], box.levels.map{|e| e.assignment_type})
+    assert_equal([10, 11, nil, nil, nil], box.levels.map{|e| e.grouping_type})
+    assert_equal([nil, 21, nil, nil, nil], box.levels.map{|e| e.grouping_type_parameter})
+    assert_equal([nil, nil, nil, nil, 34], box.levels.map{|e| e.sub_track_id})
+  end
+end