dsktool 0.2.1 → 0.4.1

data/test/tc_dos_disks.rb

@@ -13,7 +13,9 @@ class TestDOSDisks <Test::Unit::TestCase
 		assert(DSK.is_dsk_file?("file.DSK"))
 		assert(DSK.is_dsk_file?("file.dsk.gz"))
 		assert(DSK.is_dsk_file?("file.po"))
-		assert(DSK.is_dsk_file?("file.po.gz"))
+		assert(DSK.is_dsk_file?("file.po.gz"))
+    assert(DSK.is_dsk_file?("file.do"))
+    assert(DSK.is_dsk_file?("file.DO.gz"))
 		assert(!DSK.is_dsk_file?("file.dsk.zip"))
 
 	end
@@ -22,24 +24,76 @@ class TestDOSDisks <Test::Unit::TestCase
 		assert_raise(Errno::ENOENT,"non existant file should throw an error") {dsk=DSK.read("NonExistantFileName.not")}
 	end
 
+  def test_write_to_dsk
+    dsk=DSK.create_new(:dos33)
+    test_file=TextFile.new("TESTFILE","Is this mike on?")
+    dsk.add_file(test_file)
+    assert(dsk.files[test_file.filename]!=nil,"dsk should have a file called #{test_file.filename}")
+    assert_equal(test_file,dsk.files[test_file.filename])
+    
+    #test we can write muliple files (this also tests we are correctly tracking sectors as being used)
+    test_files=[]
+    for i in 0..20
+      t=dsk.make_file("TEST#{i}","TEST #{i} "+"*"*i*100)
+      test_files<<t
+      dsk.add_file(t)
+    end    
+    
+    for i in 0..20
+      assert_equal(test_files[i],dsk.files[test_files[i].filename])
+    end
+    
+    #test we can make other file types
+    [
+      TextFile,
+      BinaryFile,
+      AppleSoftFile
+    ].each do |file_class|
+      test_file=file_class.new("TEST_"+file_class.to_s.upcase,"\FF"*256)
+      dsk.add_file(test_file)
+      assert_equal(test_file,dsk.files[test_file.filename])
+    end
+    
+    
+    #make sure we can overwrite the same file (which also tests we are freeing sectors when files are deleted)
+    for i in 0..250
+      t=dsk.make_file("MULTICOPY","TEST #{i} ")      
+      dsk.add_file(t)      
+      assert_equal(t,dsk.files[t.filename])
+    end     
+    
+    #check none of the above has clobbered our original 20 test files
+    for i in 0..20
+      assert_equal(test_files[i],dsk.files[test_files[i].filename])
+    end
+  
+  #save disk for later examination
+  dsk.save_as("dos_write_test.dsk")
 
+  end
+  
+  def test_free_sector_list
+    dskname=File.dirname(__FILE__)+"//white_11a.dsk"
+    dsk=DSK.read(dskname)
+		assert_equal(:dos,dsk.file_system,"#{dskname} should be DOS 3.3 format")
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+    assert(!dsk.free_sector_list.nil?,"should have at least 1 free sector")
+  end
 	def test_dump_sector
 		dskname=File.dirname(__FILE__)+"//AAL_1.DSK"
 		dsk=DSK.read(dskname)
 		assert_equal(dsk.dump_sector(0,0).length,dsk.dump_sector(0,2).length,"sector dumps should be consistent length")
-		puts dsk.dump_sector(0,0)
-		puts dsk.dump_sector(0,2)
 	end
 
 	def test_empty_dsk
 		dsk=DSK.new()
-		assert(!dsk.is_dos33?,"empty DSK should not be DOS 3.3 format")
+		assert(dsk.file_system!=:dos,"empty DSK should not be DOS 3.3 format")
 	end
 
 	def test_open_url_to_compressed_dsk
 		dskname="http://www.apple2.org.za/mirrors/ftp.apple.asimov.net/images/games/adventure/vaults_of_zurich.dsk.gz"
 		dsk=DSK.read(dskname)
-		assert(dsk.is_dos33?,"#{dskname} should be DOS 3.3 format")
+		assert_equal(:dos,dsk.file_system,"#{dskname} should be DOS 3.3 format")
 		assert(dsk.files.length>0,"#{dskname} should have at least one file")
 		
 		hello_file=dsk.files["HELLO"]
@@ -50,10 +104,13 @@ class TestDOSDisks <Test::Unit::TestCase
 	def test_simple_dos_dsk
 		dskname=File.dirname(__FILE__)+"//dos33_with_adt.dsk"
 		dsk=DSK.read(dskname)
-		assert(dsk.is_dos33?,"#{dskname} should be DOS 3.3 format")
+		assert_equal(:dos,dsk.file_system,"#{dskname} should be DOS 3.3 format")
 		assert(dsk.files.length>0,"#{dskname} should have at least one file")
-		
+
+    assert(!dsk.find_catalog_slot("HELLO").nil?,"should find catalog slot for HELLO")
+    
 		hello_file=dsk.files["HELLO"]
+    
 		assert(hello_file!=nil,"#{dskname} should have a file called HELLO")
 		assert(hello_file.instance_of?(AppleSoftFile),"HELLO should be an AppleSoft file")
 		assert(hello_file.to_s.length>0,"HELLO should have non-zero length")
@@ -65,26 +122,44 @@ class TestDOSDisks <Test::Unit::TestCase
 		assert(binary_file.to_s.length>0,"MUFFIN should have non-zero length")		
 		assert(binary_file.disassembly.length>0,"MUFFIN disassembly should have non-zero length")
 		assert(binary_file.disassembly[0..4]=="0803:","MUFFIN disassembly should start at $803")
+		assert(!binary_file.can_be_picture?,"MUFFIN should NOT be viewable as a picture")
 
 		
 		integer_file=dsk.files["APPLESOFT"]
 		assert(integer_file!=nil,"#{dskname} should have a file called APPLESOFT")
 		assert(integer_file.instance_of?(IntegerBasicFile),"HELLO should be an IntegetBasic file")
 		assert(integer_file.to_s.length>0,"APPLESOFT should have non-zero length")
-		assert(integer_file.to_s[0..5]=="10 REM","APPLESOFT should start '10 REM'")		
+		assert(integer_file.to_s[0..5]=="10 REM","APPLESOFT should start '10 REM'")		
+		assert(!integer_file.can_be_picture?,"APPLESOFT should NOT be viewable as a picture")
+
 	end
 
 	def test_scasm_file
 		dskname=File.dirname(__FILE__)+"//AAL_1.DSK"
 		dsk=DSK.read(dskname)
-		assert(dsk.is_dos33?,"#{dskname} should be DOS 3.3 format")
-		assert(dsk.files.length>0,"#{dskname} should have at least one file")
-		
+		assert_equal(:dos,dsk.file_system,"#{dskname} should be DOS 3.3 format")
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")		
 		asm_file=dsk.files["MORSE CODE"]
 		assert(asm_file!=nil,"#{dskname} should have a file called MORSE CODE")
-		assert(asm_file.instance_of?(SCAsmFile),"MORSE CODE should be an SCasm file")
+		assert(asm_file.instance_of?(SCAsmFile),"MORSE CODE should be an SCasm file")
+		assert(!asm_file.can_be_picture?,"MORSE CODE should NOT be viewable as a picture")
 		assert(asm_file.to_s.length>0,"MORSE CODE should have non-zero length")
-		assert(!(asm_file.to_s=~/930\W*.LIST OFF/).nil?,"MORSE CODE should start '930        .LIST OFF'")
-	end
+		assert(!(asm_file.to_s=~/930\W*.LIST OFF/).nil?,"MORSE CODE should start '930        .LIST OFF'")
 
+	end
+	
+	def test_40_track_file
+		dskname=File.dirname(__FILE__)+"//white_03b.dsk"
+		dsk=DSK.read(dskname)
+		assert_equal(:dos,dsk.file_system,"#{dskname} should be DOS 3.3 format")
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+		assert_equal(40,dsk.track_count,"#{dskname} should have 40 tracks")
+
+		pic_file=dsk.files["RIP.PIC"]
+		assert(pic_file!=nil,"#{dskname} should have a file called RIP.PIC")
+		assert(pic_file.instance_of?(BinaryFile),"RIP.PIC should be a binary file")
+		assert(pic_file.can_be_picture?,"RIP.PIC should be viewable as a picture")
+		assert_equal("\211PNG\r\n\032\n",pic_file.to_png[0..7])
+	end
+  
 end

data/test/tc_nadol_disks.rb

@@ -10,15 +10,17 @@ class TestNADOLDisks <Test::Unit::TestCase
 
 	def test_empty_dsk
 		dsk=DSK.new()
-		assert(!dsk.is_nadol?,"empty DSK should not be NADOL format")
+		assert(dsk.file_system!=:nadol,"empty DSK should not be NADOL format")
+    dsk.set_sector(0,0,"*")
+    assert_equal(dsk.get_sector(0,0)[0],"*"[0],"set_sector wrote 1st byte OK")
+    assert_equal(dsk.get_sector(0,0)[1],0,"set_sector wrote 2nd byte OK")
 	end
 
 	def test_simple_nadol_dsk
 		dskname=File.dirname(__FILE__)+"//nadol.dsk"
 		dsk=DSK.read(dskname)
-		assert(dsk.is_nadol?,"#{dskname} should be NADOL format")
+		assert_equal(:nadol,dsk.file_system,"#{dskname} should be NADOL format")
 		assert(dsk.files.length>0,"#{dskname} should have at least one file")
-		dsk.dump_catalog
 		nadol_file=dsk.files["NADOL"]
 		assert(nadol_file!=nil,"#{dskname} should have a file called NADOL")
 		assert(nadol_file.to_s.length==16128,"NADOL should be 16128 bytes long")
@@ -28,9 +30,49 @@ class TestNADOLDisks <Test::Unit::TestCase
 		assert(brickout_file!=nil,"#{dskname} should have a file called BRICKOUT")
 		assert(NADOLTokenisedFile.can_be_nadol_tokenised_file?(dsk.files["BRICKOUT"].contents),"BRICKOUT should be NADOL tokenised file")
 		assert(nadol_file.respond_to?(:disassembly),"BRICKOUT can't be disassembled")
-		s=brickout_file.to_s		
+		s=brickout_file.to_s
+		assert(!brickout_file.can_be_picture?,"BRICK-OUT should NOT be viewable as a picture")		
 		assert_equal("; LORES BRICK-OUT GAME",s[0..21],"BRICK-OUT source should detokenise")
-		assert_equal("; @ \"NAIII\"",dsk.files["NAIII"].to_s[0..10],"NAIII source should detokenise")
+		assert_equal("; @ \"NAIII\"",dsk.files["NAIII"].to_s[0..10],"NAIII source should detokenise")
+
+    test_file=NADOLFile.new("TESTFILE","Is this mike on?")
+    assert(test_file!=dsk.files["LOGO"],"comparison between files doesn't have false positive")
+    dsk.add_file(test_file)
+    assert(dsk.files[test_file.filename]!=nil,"#{dskname} should have a file called #{test_file.filename}")
+    assert_equal(test_file,dsk.files[test_file.filename])
+
+    #try to round_trip a tokenised NADOL file
+    copy_of_tokenised_file=dsk.make_file("BBALL2",dsk.files["BOUNCINGBALL"].to_s,{:tokenise=>true})
+    assert_equal(dsk.files["BOUNCINGBALL"].to_s,copy_of_tokenised_file.to_s,"NADOL tokenised file should round-trip")
+    dsk.add_file(copy_of_tokenised_file)
+    
+    #test we can write muliple files (this also tests we are correctly tracking sectors as being used)
+    test_files=[]
+    for i in 0..20
+      t=dsk.make_file("TEST#{i}","TEST #{i} "+"*"*i*100)
+      test_files<<t
+      dsk.add_file(t)
+    end    
+    puts dsk.dump_catalog
+    dsk.save_as("nadol2.po")
+    for i in 0..20
+      assert_equal(test_files[i],dsk.files[test_files[i].filename])
+    end
+    
+    #make sure we can overwrite the same file (which also tests we are freeing sectors when files are deleted)
+    for i in 0..250
+      t=dsk.make_file("MULTICOPY","TEST #{i} ")
+      puts "iteratio #{i}"
+      dsk.add_file(t)
+      assert_equal(t,dsk.files[t.filename])
+    end   
+    
+    #check picture files can be extracted
+		pic_file=dsk.files["LOGO"]
+		assert(pic_file!=nil,"#{dskname} should have a file called LOGO")
+		assert(pic_file.can_be_picture?,"LOGO should be viewable as a picture")
+		assert_equal("\211PNG\r\n\032\n",pic_file.to_png[0..7])
+
 	end
 
 end

data/test/tc_pascal_disks.rb

@@ -0,0 +1,47 @@
+#make sure the relevant folder with our libraries is in the require path
+lib_path=File.expand_path(File.dirname(__FILE__)+"//..//lib")
+$:.unshift(lib_path) unless $:.include?(lib_path)
+
+require 'test/unit'
+require 'DSK'
+
+class TestPascalDisks <Test::Unit::TestCase
+	
+	def test_other_dsk_types
+		dsk=DSK.new()
+		assert(dsk.file_system!=:pascal,"empty DSK should not be Pascal format")
+
+		dskname=File.dirname(__FILE__)+"//dos33_with_adt.dsk"
+		dsk=DSK.read(dskname)
+		assert(dsk.file_system!=:pascal,"#{dskname} should not be Pascal format")
+
+		dskname=File.dirname(__FILE__)+"//nadol.dsk"
+		dsk=DSK.read(dskname)
+		assert(dsk.file_system!=:pascal,"#{dskname} should not be Pascal format")
+
+	end
+	def test_simple_pascal_disk
+
+		dskname=File.dirname(__FILE__)+"//Algebra Mentor (19xx)(John C. Miller)(Disk 1 of 7 Side A)(Student Disk 1).dsk.gz"
+		dsk=DSK.read(dskname)
+		assert_equal(:pascal,dsk.file_system,"#{dskname} should have Pascal file system")
+		assert_equal("A1011",dsk.volume_name)
+
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+	end
+
+	def test_pascal_foto_disk
+
+		dskname=File.dirname(__FILE__)+"//camps.dsk.gz"
+		dsk=DSK.read(dskname)
+		assert_equal(:pascal,dsk.file_system,"#{dskname} should have Pascal file system")
+		assert_equal("DIARRHE",dsk.volume_name)
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+		non_foto_file=dsk.files["SYSTEM.MISCINFO"]
+		assert(!non_foto_file.can_be_picture?)
+		foto_file=dsk.files["CAMPS.FOTO"]
+		assert(foto_file.can_be_picture?)
+	end
+
+
+end

data/test/tc_prodos_disks.rb

@@ -0,0 +1,78 @@
+#make sure the relevant folder with our libraries is in the require path
+lib_path=File.expand_path(File.dirname(__FILE__)+"//..//lib")
+$:.unshift(lib_path) unless $:.include?(lib_path)
+
+require 'test/unit'
+require 'DSK'
+
+class TestProDOSDisks <Test::Unit::TestCase
+	
+	def test_other_dsk_types
+		dsk=DSK.new()
+		assert(dsk.file_system!=:prodos,"empty DSK should not be PRODOS format")
+
+		dskname=File.dirname(__FILE__)+"//dos33_with_adt.dsk"
+		dsk=DSK.read(dskname)
+		assert(dsk.file_system!=:prodos,"#{dskname} should not be ProDOS format")
+
+		dskname=File.dirname(__FILE__)+"//nadol.dsk"
+		dsk=DSK.read(dskname)
+		assert(dsk.file_system!=:prodos,"#{dskname} should not be ProDOS format")
+
+	end
+	def test_simple_prodos_disk
+
+		dskname=File.dirname(__FILE__)+"//dosmaster.po"
+		dsk=DSK.read(dskname)
+		assert_equal(:prodos,dsk.file_system,"#{dskname} should have ProDOS file system")
+		assert_equal(:physical,dsk.sector_order,"#{dskname} should have ProDOS order")
+		assert_equal("NEW.DISK",dsk.volume_name)
+
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+		bas_file=dsk.files["STARTUP"]
+		assert(bas_file!=nil,"#{dskname} should have a file called STARTUP")
+		assert_equal("10 PRINT CHR$ (4)\"PR#3\"",bas_file.to_s[0..22],"STARTUP should detokenise")
+	end
+
+	def test_dos_interleave_prodos_disks
+
+		dskname=File.dirname(__FILE__)+"//ADTPRO-1.0.1.DSK"
+		dsk=DSK.read(dskname)
+		assert_equal(:prodos,dsk.file_system,"#{dskname} should have ProDOS file system")
+		assert_equal(:prodos_from_dos,dsk.sector_order,"#{dskname} should have DOS sector order")
+		assert_equal("ADTPRO.1.0.1",dsk.volume_name)
+
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+		bas_file=dsk.files["STARTUP"]
+		assert(bas_file!=nil,"#{dskname} should have a file called STARTUP")
+		assert_equal("10 TEXT : NORMAL : HOME",bas_file.to_s[0..22],"STARTUP should detokenise")
+		
+		dskname=File.dirname(__FILE__)+"//Apple Works V5.0 (1993)(Beagle Bros)(Disks 5 of 6).dsk.gz"
+		dsk=DSK.read(dskname)
+		assert_equal(:prodos,dsk.file_system,"#{dskname} should have ProDOS file system")
+		assert_equal(:prodos_from_dos,dsk.sector_order,"#{dskname} should have DOS sector order")
+		assert_equal("MOVE13",dsk.volume_name)
+
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+#		puts dsk.dump_catalog
+		awp_file=dsk.files["AW.INITS/NARNIA.KNAVES"]
+		assert(bas_file!=nil,"#{dskname} should have a file called  AW.INITS/NARNIA.KNAVES")
+		assert_equal("This bonus screen blanker",awp_file.to_s[0..24])
+		
+	end
+	
+	def test_tree_structures
+		dskname=File.dirname(__FILE__)+"//Geos (1988)(Berkeley Softworks)(Disk 1 of 4 Side A).dsk.gz"
+		dsk=DSK.read(dskname)
+		assert_equal(:prodos,dsk.file_system,"#{dskname} should have ProDOS file system")
+		assert_equal(:prodos_from_dos,dsk.sector_order,"#{dskname} should have DOS sector order")
+		assert_equal("GEOS.BOOT",dsk.volume_name)
+
+		assert(dsk.files.length>0,"#{dskname} should have at least one file")
+		tree_file=dsk.files["SYSTEM/Mouse"]
+		assert(tree_file!=nil,"#{dskname} should have a file called SYSTEM/Mouse")
+		assert_equal(645,tree_file.contents.length,"SYSTEM/Mouse should be 645 bytes long")
+
+	end
+
+end

data/test/ts_test_all.rb

@@ -2,5 +2,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'tc_dos_disks'
+require 'tc_prodos_disks'
 require 'tc_disassembly'
 require 'tc_nadol_disks'
+require 'tc_pascal_disks'