Initial Commit
This commit is contained in:
@@ -0,0 +1,229 @@
|
||||
import XCTest
|
||||
@testable import KJamsClone
|
||||
|
||||
final class KJamsCloneTests: XCTestCase {
|
||||
func packet(_ instruction: UInt8, _ data: [UInt8]) -> [UInt8] { [9,instruction,0,0] + Array((data + Array(repeating: 0,count:16)).prefix(16)) + [0,0,0,0] }
|
||||
func testPresetTileXORAndInvalidCoordinates() {
|
||||
var d = CDGDecoder()
|
||||
d.apply(packet(1,[3,0])); XCTAssertEqual(d.pixels[0],3)
|
||||
d.apply(packet(6,[0,5,1,1] + Array(repeating:63,count:12)))
|
||||
XCTAssertEqual(d.pixels[12*300+6],5)
|
||||
d.apply(packet(38,[0,5,1,1] + Array(repeating:63,count:12)))
|
||||
XCTAssertEqual(d.pixels[12*300+6],0)
|
||||
let old = d.pixels; d.apply(packet(6,[1,2,31,63])); XCTAssertEqual(d.pixels,old)
|
||||
}
|
||||
func testSeekAndTruncatedPacket() {
|
||||
var d = CDGDecoder()
|
||||
let data = Data(packet(1,[2,0]) + packet(1,[7,0]) + [9])
|
||||
d.render(data,at:1); XCTAssertEqual(d.pixels[0],7); XCTAssertEqual(d.packetIndex,2)
|
||||
d.render(data,at:1.0/300); XCTAssertEqual(d.pixels[0],2)
|
||||
d.render(data,at:0); XCTAssertEqual(d.pixels[0],0)
|
||||
}
|
||||
func testPaletteBorderScrollAndImage() {
|
||||
var d = CDGDecoder()
|
||||
d.apply(packet(30,[63,63])); XCTAssertEqual(d.palette[0],0xFFFFFFFF)
|
||||
d.apply(packet(2,[4])); XCTAssertEqual(d.pixels[0],4); XCTAssertEqual(d.pixels[12*300+6],0)
|
||||
d.apply(packet(20,[3,16,0])); XCTAssertEqual(d.pixels[100*300],3)
|
||||
d.apply(packet(24,[0,32,0])); XCTAssertEqual(d.pixels[100*300+294],3)
|
||||
XCTAssertEqual(d.image()?.width,288)
|
||||
}
|
||||
func testSQLitePersistenceDedupRatingsAndHistory() throws {
|
||||
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at: folder,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:folder) }
|
||||
let url = folder.appendingPathComponent("test.sqlite")
|
||||
do {
|
||||
let db = try Library(url:url)
|
||||
try db.add(title:"Singer's Song",audio:"/test.mp3",cdg:nil)
|
||||
try db.add(title:"Duplicate",audio:"/test.mp3",cdg:"/test.cdg")
|
||||
let song = try XCTUnwrap(db.songs().first)
|
||||
try db.rate(song.id,5); XCTAssertThrowsError(try db.rate(song.id,6))
|
||||
try db.addEntity("singers",name:"O'Neil"); try db.addEntity("venues",name:"Hall")
|
||||
try db.record(song.id,singer:db.entities("singers").first?.id,venue:db.entities("venues").first?.id)
|
||||
}
|
||||
let reopened = try Library(url:url); let songs = try reopened.songs()
|
||||
XCTAssertEqual(songs.count,1); XCTAssertEqual(songs[0].rating,5); XCTAssertEqual(songs[0].plays,1); XCTAssertEqual(songs[0].cdg,"/test.cdg")
|
||||
XCTAssertEqual(try reopened.entities("singers").first?.name,"O'Neil")
|
||||
}
|
||||
func testPairedImportAndContentDedup() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let audio = root.appendingPathComponent("Test.mp3"), cdg = root.appendingPathComponent("Test.CDG")
|
||||
try Data([1,2,3]).write(to:audio); try Data(packet(1,[2,0])).write(to:cdg)
|
||||
let db = try Library(url:root.appendingPathComponent("test.sqlite"))
|
||||
let importer = Importer(media:root.appendingPathComponent("Media"))
|
||||
try importer.run([audio],library:db); try importer.run([audio],library:db)
|
||||
XCTAssertEqual(try db.songs().count,1)
|
||||
XCTAssertNotNil(try db.songs().first?.cdg)
|
||||
}
|
||||
|
||||
func testZippedMP3GImportAndUnsafeArchiveRejection() throws {
|
||||
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:folder,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:folder) }
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let db = try Library(url:folder.appendingPathComponent("db.sqlite"))
|
||||
let importer = Importer(media:folder.appendingPathComponent("Media"))
|
||||
try importer.run([fixtures.appendingPathComponent("Demo.zip")],library:db)
|
||||
let song = try XCTUnwrap(db.songs().first)
|
||||
XCTAssertEqual(song.title,"Demo"); XCTAssertNotNil(song.cdg)
|
||||
XCTAssertTrue(FileManager.default.fileExists(atPath:song.audio))
|
||||
XCTAssertThrowsError(try importer.run([fixtures.appendingPathComponent("Unsafe.zip")],library:db))
|
||||
}
|
||||
@MainActor func testMP3PlaybackPauseAndSeek() throws {
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let player = Player()
|
||||
defer { player.stop() }
|
||||
try player.load(Song(id:1,title:"Demo",audio:fixtures.appendingPathComponent("Demo.mp3").path,cdg:fixtures.appendingPathComponent("Demo.cdg").path,rating:0,plays:0))
|
||||
XCTAssertGreaterThan(player.duration,3.9); XCTAssertTrue(player.playing)
|
||||
player.toggle(); XCTAssertFalse(player.playing)
|
||||
player.seek(2); XCTAssertEqual(player.time,2,accuracy:0.05); XCTAssertNotNil(player.image)
|
||||
player.seek(0.1); XCTAssertEqual(player.time,0.1,accuracy:0.05)
|
||||
}
|
||||
@MainActor func testCreateSingerAndVenueThroughAppModel() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let model = AppModel(storageURL: root)
|
||||
XCTAssertNil(model.error)
|
||||
let singer = try model.createEntity(.singer, name: " Alex ")
|
||||
let venue = try model.createEntity(.venue, name: "Town Hall")
|
||||
XCTAssertEqual(model.singers.first?.name, "Alex")
|
||||
XCTAssertEqual(model.venues.first?.name, "Town Hall")
|
||||
XCTAssertEqual(try model.createEntity(.singer, name: "Alex"), singer)
|
||||
XCTAssertEqual(model.singers.count, 1)
|
||||
XCTAssertThrowsError(try model.createEntity(.venue, name: " "))
|
||||
let reopened = AppModel(storageURL: root)
|
||||
XCTAssertEqual(reopened.singers.first?.id, singer)
|
||||
XCTAssertEqual(reopened.venues.first?.id, venue)
|
||||
}
|
||||
|
||||
@MainActor func testVenuesShareSingersAndRememberSelection() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let model = AppModel(storageURL:root)
|
||||
let hall = try model.createEntity(.venue,name:"Hall")
|
||||
let alex = try model.createEntity(.singer,name:"Alex")
|
||||
let club = try model.createEntity(.venue,name:"Club")
|
||||
XCTAssertTrue(model.venueSingers.isEmpty)
|
||||
model.membership(singer:alex,included:true)
|
||||
XCTAssertEqual(model.venueSingers.map(\.id),[alex])
|
||||
model.chooseVenue(hall); XCTAssertEqual(model.venueSingers.map(\.id),[alex])
|
||||
model.chooseVenue(club); model.membership(singer:alex,included:false)
|
||||
XCTAssertTrue(model.venueSingers.isEmpty)
|
||||
let reopened = AppModel(storageURL:root)
|
||||
XCTAssertEqual(reopened.currentVenue,club); XCTAssertTrue(reopened.venueSingers.isEmpty)
|
||||
reopened.chooseVenue(hall); XCTAssertEqual(reopened.venueSingers.map(\.id),[alex])
|
||||
XCTAssertEqual(reopened.singers.count,1)
|
||||
}
|
||||
func testMigrationAndMembershipRemovalDoesNotReappear() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let url = root.appendingPathComponent("db.sqlite")
|
||||
var singer: Int64 = 0, venue: Int64 = 0
|
||||
do {
|
||||
let db = try Library(url:url)
|
||||
try db.add(title:"Song",audio:"/a.mp3",cdg:nil)
|
||||
try db.addEntity("singers",name:"Alex"); try db.addEntity("venues",name:"Hall")
|
||||
singer = try XCTUnwrap(db.entities("singers").first?.id); venue = try XCTUnwrap(db.entities("venues").first?.id)
|
||||
try db.record(XCTUnwrap(db.songs().first?.id),singer:singer,venue:venue)
|
||||
try db.execute("PRAGMA user_version=1")
|
||||
}
|
||||
do {
|
||||
let migrated = try Library(url:url)
|
||||
XCTAssertEqual(try migrated.members(of:venue).map(\.id),[singer])
|
||||
try migrated.setMembership(singer:singer,venue:venue,included:false)
|
||||
}
|
||||
let reopened = try Library(url:url)
|
||||
XCTAssertTrue(try reopened.members(of:venue).isEmpty)
|
||||
XCTAssertEqual(try reopened.history(venue:venue).count,1)
|
||||
}
|
||||
func testQueuePlaylistsPreferencesAndDeletion() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let db = try Library(url:root.appendingPathComponent("db.sqlite"))
|
||||
try db.add(title:"First",audio:"/1.mp3",cdg:nil)
|
||||
try db.add(title:"Second",audio:"/2.mp3",cdg:nil)
|
||||
let songs = try db.songs()
|
||||
try db.addEntity("singers",name:"Alex"); try db.addEntity("venues",name:"Hall"); try db.addEntity("venues",name:"Club")
|
||||
let singer = try XCTUnwrap(db.entities("singers").first?.id)
|
||||
let hall = try XCTUnwrap(db.entities("venues").first(where: { $0.name == "Hall" })?.id)
|
||||
let club = try XCTUnwrap(db.entities("venues").first(where: { $0.name == "Club" })?.id)
|
||||
XCTAssertThrowsError(try db.enqueue(song:songs[0].id,singer:singer,venue:hall))
|
||||
try db.setMembership(singer:singer,venue:hall,included:true)
|
||||
try db.enqueue(song:songs[0].id,singer:singer,venue:hall); try db.enqueue(song:songs[1].id,singer:singer,venue:hall)
|
||||
XCTAssertTrue(try db.queue(venue:club).isEmpty)
|
||||
let second = try XCTUnwrap(db.queue(venue:hall).last)
|
||||
try db.moveQueue(second.id,venue:hall,by:-1)
|
||||
XCTAssertEqual(try db.queue(venue:hall).first?.songID,songs[1].id)
|
||||
let preference = SongPreference(pitch:3,tempo:0.85,rating:4)
|
||||
try db.savePreference(song:songs[0].id,singer:singer,value:preference)
|
||||
XCTAssertEqual(try db.preference(song:songs[0].id,singer:singer),preference)
|
||||
XCTAssertThrowsError(try db.savePreference(song:songs[0].id,singer:singer,value:.init(pitch:99)))
|
||||
try db.addEntity("playlists",name:"Party")
|
||||
let playlist = try XCTUnwrap(db.entities("playlists").first?.id)
|
||||
try db.addToPlaylist(playlist,song:songs[0].id); try db.addToPlaylist(playlist,song:songs[0].id)
|
||||
XCTAssertEqual(try db.playlistSongIDs(playlist),[songs[0].id])
|
||||
try db.record(songs[0].id,singer:singer,venue:hall)
|
||||
try db.rename("singers",id:singer,name:"Alex Jones")
|
||||
XCTAssertEqual(try db.history(venue:hall).first?.singer,"Alex Jones")
|
||||
try db.deleteEntity("singers",id:singer)
|
||||
XCTAssertTrue(try db.queue(venue:hall).isEmpty)
|
||||
XCTAssertEqual(try db.history(venue:hall).count,1)
|
||||
try db.selectVenue(hall); try db.deleteEntity("venues",id:hall)
|
||||
XCTAssertNil(try db.currentVenue()); XCTAssertEqual(try db.history(venue:nil).count,1)
|
||||
}
|
||||
@MainActor func testTempoSourceClockPauseAndResume() async throws {
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let player = Player(); defer { player.stop() }
|
||||
let song = Song(id:1,title:"Demo",audio:fixtures.appendingPathComponent("Demo.mp3").path,cdg:fixtures.appendingPathComponent("Demo.cdg").path,rating:0,plays:0)
|
||||
try player.load(song,preference:.init(pitch:2,tempo:1.5,rating:3))
|
||||
XCTAssertEqual(player.pitch,2); XCTAssertEqual(player.tempo,1.5)
|
||||
try await Task.sleep(nanoseconds:500_000_000)
|
||||
XCTAssertGreaterThan(player.time,0.45); XCTAssertLessThan(player.time,1.3)
|
||||
player.toggle(); let paused = player.time
|
||||
try await Task.sleep(nanoseconds:100_000_000)
|
||||
XCTAssertEqual(player.time,paused,accuracy:0.025)
|
||||
player.seek(1.5); player.toggle()
|
||||
try await Task.sleep(nanoseconds:200_000_000)
|
||||
XCTAssertGreaterThan(player.time,1.6); XCTAssertNotNil(player.image)
|
||||
}
|
||||
func testNewTestMediaMetadataAndCDGPairImport() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let db = try Library(url:root.appendingPathComponent("db.sqlite"))
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let importer = Importer(media:root.appendingPathComponent("Media"))
|
||||
try importer.run([fixtures.appendingPathComponent("TestTrack.cdg")],library:db)
|
||||
let song = try XCTUnwrap(db.songs().first)
|
||||
XCTAssertEqual(song.title,"MP3 Plus G Test")
|
||||
XCTAssertEqual(song.artist,"KJamsClone Test Generator")
|
||||
XCTAssertNotNil(song.cdg)
|
||||
let bytes = try Data(contentsOf:fixtures.appendingPathComponent("TestTrack.cdg"))
|
||||
XCTAssertEqual(bytes.count,20*300*24)
|
||||
var decoder = CDGDecoder(); decoder.render(bytes,at:2)
|
||||
XCTAssertTrue(decoder.pixels.contains(1)); XCTAssertTrue(decoder.pixels.contains(2))
|
||||
}
|
||||
@MainActor func testAutomaticVenueQueueAdvancesAndRecordsSinger() async throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let model = AppModel(storageURL:root); defer { model.player.stop() }
|
||||
_ = try model.createEntity(.venue,name:"Test Hall")
|
||||
_ = try model.createEntity(.singer,name:"Alex")
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
model.importFiles([fixtures.appendingPathComponent("Demo.zip")])
|
||||
let song = try XCTUnwrap(model.songs.first)
|
||||
model.enqueue(song.id); model.enqueue(song.id); model.playQueueNext()
|
||||
XCTAssertEqual(model.queue.count,1); XCTAssertEqual(model.history.count,1)
|
||||
model.player.seek(model.player.duration-0.1)
|
||||
for _ in 0..<25 {
|
||||
if model.queue.isEmpty { break }
|
||||
try await Task.sleep(nanoseconds:100_000_000)
|
||||
}
|
||||
XCTAssertNil(model.error); XCTAssertTrue(model.queue.isEmpty)
|
||||
XCTAssertEqual(model.history.count,2); XCTAssertEqual(model.history.first?.singer,"Alex")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user