aboutsummaryrefslogtreecommitdiffstats
path: root/src/test/java/com/jsyn/ports
diff options
context:
space:
mode:
Diffstat (limited to 'src/test/java/com/jsyn/ports')
-rw-r--r--src/test/java/com/jsyn/ports/TestQueuedDataPort.java549
-rw-r--r--src/test/java/com/jsyn/ports/TestSequentialData.java55
-rw-r--r--src/test/java/com/jsyn/ports/TestSet.java89
3 files changed, 693 insertions, 0 deletions
diff --git a/src/test/java/com/jsyn/ports/TestQueuedDataPort.java b/src/test/java/com/jsyn/ports/TestQueuedDataPort.java
new file mode 100644
index 0000000..65c0127
--- /dev/null
+++ b/src/test/java/com/jsyn/ports/TestQueuedDataPort.java
@@ -0,0 +1,549 @@
+/*
+ * Copyright 2009 Phil Burk, Mobileer Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.jsyn.ports;
+
+import com.jsyn.JSyn;
+import com.jsyn.Synthesizer;
+import com.jsyn.data.FloatSample;
+import com.jsyn.data.SequentialData;
+import com.jsyn.data.ShortSample;
+import com.jsyn.unitgen.FixedRateMonoReader;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Test sample and envelope queuing and looping.
+ *
+ * @author Phil Burk, (C) 2009 Mobileer Inc
+ */
+public class TestQueuedDataPort {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(TestQueuedDataPort.class);
+
+ private static Synthesizer synth;
+ private static final float[] floatData = {
+ 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f
+ };
+ private static FloatSample floatSample;
+ private static FixedRateMonoReader reader;
+
+ @BeforeAll
+ private static void setUp() {
+ synth = JSyn.createSynthesizer();
+ synth.setRealTime(false);
+ synth.start();
+ }
+
+ @AfterAll
+ private static void tearDown() {
+ synth.stop();
+ }
+
+ private void queueDirect(UnitDataQueuePort port, SequentialData data, int startFrame,
+ int numFrames) {
+ queueDirect(port, data, startFrame, numFrames, 0);
+ }
+
+ private void queueDirect(UnitDataQueuePort port, SequentialData data, int startFrame,
+ int numFrames, int numLoops) {
+ QueueDataCommand command = port.createQueueDataCommand(data, startFrame, numFrames);
+ command.setNumLoops(numLoops);
+ port.addQueuedBlock(command);
+ }
+
+ @Test
+ public void testQueueSingleShort() {
+ short[] data = {
+ 234, -9876, 4567
+ };
+ ShortSample sample = new ShortSample(data.length, 1);
+ sample.write(data);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ assertFalse(dataQueue.hasMore(), "start empty");
+
+ queueDirect(dataQueue, sample, 0, data.length);
+ checkQueuedData(data, dataQueue, 0, data.length);
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testQueueSingleFloat() {
+ float[] data = {
+ 0.4f, 1.9f, 22.7f
+ };
+ FloatSample sample = new FloatSample(data.length, 1);
+ sample.write(data);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ assertFalse(dataQueue.hasMore(), "start empty");
+
+ queueDirect(dataQueue, sample, 0, data.length);
+ checkQueuedData(data, dataQueue, 0, data.length);
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testQueueOutOfBounds() {
+ float[] data = {
+ 0.4f, 1.9f, 22.7f
+ };
+ FloatSample sample = new FloatSample(data.length, 1);
+ sample.write(data);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ boolean caught = false;
+ try {
+ queueDirect(dataQueue, sample, 0, sample.getNumFrames() + 1); // should cause an error!
+ } catch(IllegalArgumentException e) {
+ caught = true;
+ }
+ assertTrue(caught, "expect exception when we go past end of the array");
+
+ caught = false;
+ try {
+ queueDirect(dataQueue, sample, 1, sample.getNumFrames()); // should cause an error!
+ } catch(IllegalArgumentException e) {
+ caught = true;
+ }
+ assertTrue(caught, "expect exception when we go past end of the array");
+
+ caught = false;
+ try {
+ queueDirect(dataQueue, sample, -1, sample.getNumFrames()); // should cause an error!
+ } catch(IllegalArgumentException e) {
+ caught = true;
+ }
+ assertTrue(caught, "expect exception when we start before beginning of the array");
+ }
+
+ @Test
+ public void testQueueMultiple() {
+ short[] data = {
+ 234, 17777, -9876, 4567, -14287
+ };
+ ShortSample sample = new ShortSample(data.length, 1);
+ sample.write(data);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ assertFalse(dataQueue.hasMore(), "start empty");
+
+ queueDirect(dataQueue, sample, 1, 3);
+ queueDirect(dataQueue, sample, 0, 5);
+ queueDirect(dataQueue, sample, 2, 2);
+
+ checkQueuedData(data, dataQueue, 1, 3);
+ checkQueuedData(data, dataQueue, 0, 5);
+ checkQueuedData(data, dataQueue, 2, 2);
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testQueueNoLoops() throws InterruptedException {
+ LOGGER.debug("testQueueNoLoops() ================");
+ UnitDataQueuePort dataQueue = setupFloatSample();
+
+ dataQueue.queueOn(floatSample, synth.createTimeStamp());
+ // Advance synth so that the queue command propagates to the engine.
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ // play entire sample
+ checkQueuedData(floatData, dataQueue, 0, floatData.length);
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testQueueLoopForever() throws InterruptedException {
+ LOGGER.debug("testQueueLoopForever() ================");
+
+ UnitDataQueuePort dataQueue = setupFloatSample();
+
+ dataQueue.queue(floatSample, 0, 3);
+ dataQueue.queueLoop(floatSample, 3, 4);
+
+ // Advance synth so that the queue commands propagate to the engine.
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 0, 3);
+ checkQueuedData(floatData, dataQueue, 3, 4);
+ checkQueuedData(floatData, dataQueue, 3, 4);
+ checkQueuedData(floatData, dataQueue, 3, 4);
+ checkQueuedData(floatData, dataQueue, 3, 1);
+
+ // queue final release
+ dataQueue.queue(floatSample, 3, 5);
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+ // current loop will finish
+ checkQueuedData(floatData, dataQueue, 4, 3);
+ // release portion will play
+ checkQueuedData(floatData, dataQueue, 3, 5);
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testQueueLoopAtLeastOnce() throws InterruptedException {
+ LOGGER.debug("testQueueLoopAtLeastOnce() ================");
+
+ UnitDataQueuePort dataQueue = setupFloatSample();
+
+ dataQueue.queue(floatSample, 0, 3);
+ dataQueue.queueLoop(floatSample, 3, 2); // this should play at least once
+ dataQueue.queue(floatSample, 5, 2);
+
+ // Advance synth so that the queue commands propagate to the engine.
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 0, 3);
+ checkQueuedData(floatData, dataQueue, 3, 2);
+ checkQueuedData(floatData, dataQueue, 5, 2);
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testQueueNumLoops() throws InterruptedException {
+ LOGGER.debug("testQueueNumLoops() ================");
+ UnitDataQueuePort dataQueue = setupFloatSample();
+
+ dataQueue.queue(floatSample, 0, 2);
+
+ int numLoopsA = 5;
+ dataQueue.queueLoop(floatSample, 2, 3, numLoopsA);
+
+ dataQueue.queue(floatSample, 4, 2);
+
+ int numLoopsB = 3;
+ dataQueue.queueLoop(floatSample, 3, 4, numLoopsB);
+
+ dataQueue.queue(floatSample, 5, 2);
+
+ // Advance synth so that the queue commands propagate to the engine.
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 0, 2);
+ for (int i = 0; i < (numLoopsA + 1); i++) {
+ LOGGER.debug("loop A #" + i);
+ checkQueuedData(floatData, dataQueue, 2, 3);
+ }
+ checkQueuedData(floatData, dataQueue, 4, 2);
+ for (int i = 0; i < (numLoopsB + 1); i++) {
+ LOGGER.debug("loop B #" + i);
+ checkQueuedData(floatData, dataQueue, 3, 4);
+ }
+
+ checkQueuedData(floatData, dataQueue, 5, 2);
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ private UnitDataQueuePort setupFloatSample() {
+ floatSample = new FloatSample(floatData.length, 1);
+ floatSample.write(floatData);
+
+ synth.add(reader = new FixedRateMonoReader());
+ UnitDataQueuePort dataQueue = reader.dataQueue;
+ assertFalse(dataQueue.hasMore(), "start empty");
+ return dataQueue;
+ }
+
+ @Test
+ public void testQueueSustainLoop() throws InterruptedException {
+ LOGGER.debug("testQueueSustainLoop() ================");
+
+ UnitDataQueuePort dataQueue = setupFloatSample();
+
+ // set up sustain loops ===========================
+ floatSample.setSustainBegin(2);
+ floatSample.setSustainEnd(4);
+ floatSample.setReleaseBegin(-1);
+ floatSample.setReleaseEnd(-1);
+
+ dataQueue.queueOn(floatSample, synth.createTimeStamp());
+ // Advance synth so that the queue command propagates to the engine.
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 0, 2);
+ checkQueuedData(floatData, dataQueue, 2, 2);
+ checkQueuedData(floatData, dataQueue, 2, 2);
+ checkQueuedData(floatData, dataQueue, 2, 1); // looping
+
+ dataQueue.queueOff(floatSample, true); // queue off in middle of loop
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 3, 5); // release
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testQueueReleaseLoop() throws InterruptedException {
+ LOGGER.debug("testQueueReleaseLoop() ================");
+ UnitDataQueuePort dataQueue = setupFloatSample();
+
+ // set up sustain loops ===========================
+ floatSample.setSustainBegin(-1);
+ floatSample.setSustainEnd(-1);
+ floatSample.setReleaseBegin(4);
+ floatSample.setReleaseEnd(6);
+
+ dataQueue.queueOn(floatSample, synth.createTimeStamp());
+ // Advance synth so that the queue command propagates to the engine.
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 0, 4);
+ checkQueuedData(floatData, dataQueue, 4, 2);
+ checkQueuedData(floatData, dataQueue, 4, 2);
+ checkQueuedData(floatData, dataQueue, 4, 2); // looping in release cuz no
+ // sustain loop
+
+ dataQueue.queueOff(floatSample, true); // queue off in middle of loop
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 4, 2);
+ checkQueuedData(floatData, dataQueue, 4, 2); // still looping
+ assertTrue(dataQueue.hasMore(), "end full");
+ }
+
+ @Test
+ public void testQueueSustainReleaseLoops() throws InterruptedException {
+ LOGGER.debug("testQueueSustainReleaseLoops() ================");
+ UnitDataQueuePort dataQueue = setupFloatSample();
+
+ // set up sustain loops ===========================
+ floatSample.setSustainBegin(2);
+ floatSample.setSustainEnd(4);
+ floatSample.setReleaseBegin(5);
+ floatSample.setReleaseEnd(7);
+
+ dataQueue.queueOn(floatSample, synth.createTimeStamp());
+ // Advance synth so that the queue command propagates to the engine.
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 0, 4);
+ checkQueuedData(floatData, dataQueue, 2, 2);
+ checkQueuedData(floatData, dataQueue, 2, 1); // middle of sustain loop
+
+ dataQueue.queueOff(floatSample, true); // queue off in middle of loop
+ synth.sleepUntil(synth.getCurrentTime() + 0.01);
+
+ checkQueuedData(floatData, dataQueue, 3, 2);
+ checkQueuedData(floatData, dataQueue, 5, 2); // release loop
+ checkQueuedData(floatData, dataQueue, 5, 2); // release loop
+ assertTrue(dataQueue.hasMore(), "end full");
+ }
+
+ @Test
+ private void checkQueuedData(short[] data, UnitDataQueuePort dataQueue, int offset,
+ int numFrames) {
+ for (int i = 0; i < numFrames; i++) {
+ assertTrue(dataQueue.hasMore(), "got data");
+ double value = dataQueue.readNextMonoDouble(synth.getFramePeriod());
+ assertEquals(data[i + offset] / 32768.0, value, 0.0001, "data matches");
+ }
+ }
+
+ private void checkQueuedData(float[] data, UnitDataQueuePort dataQueue, int offset,
+ int numFrames) {
+ for (int i = 0; i < numFrames; i++) {
+ assertTrue(dataQueue.hasMore(), "got data");
+ double value = dataQueue.readNextMonoDouble(synth.getFramePeriod());
+ assertEquals(data[i + offset], value, 0.0001, "data matches");
+ }
+ }
+
+ static class TestQueueCallback implements UnitDataQueueCallback {
+ boolean gotStarted = false;
+ boolean gotLooped = false;
+ boolean gotFinished = false;
+ QueueDataEvent lastEvent;
+
+ @Override
+ public void started(QueueDataEvent event) {
+ LOGGER.debug("Callback started.");
+ gotStarted = true;
+ lastEvent = event;
+ }
+
+ @Override
+ public void looped(QueueDataEvent event) {
+ LOGGER.debug("Callback looped.");
+ gotLooped = true;
+ lastEvent = event;
+ }
+
+ @Override
+ public void finished(QueueDataEvent event) {
+ LOGGER.debug("Callback finished.");
+ gotFinished = true;
+ lastEvent = event;
+ }
+ }
+
+ @Test
+ public void testQueueCallback() {
+ float[] data = {
+ 0.2f, -8.9f, 2.7f
+ };
+ FloatSample sample = new FloatSample(data.length, 1);
+ sample.write(data);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ assertFalse(dataQueue.hasMore(), "start empty");
+
+ // Create an object to be called when the queued data is done.
+ TestQueueCallback callback = new TestQueueCallback();
+
+ QueueDataCommand command = dataQueue.createQueueDataCommand(sample, 0, data.length);
+ command.setCallback(callback);
+ command.setNumLoops(2);
+ dataQueue.addQueuedBlock(command);
+
+ // Check to see if flags get set true by callback.
+ dataQueue.firePendingCallbacks();
+ assertFalse(callback.gotStarted, "not started yet");
+ assertFalse(callback.gotLooped, "not looped yet");
+ assertFalse(callback.gotFinished, "not finished yet");
+
+ checkQueuedData(data, dataQueue, 0, 1);
+ dataQueue.firePendingCallbacks();
+ assertTrue(callback.gotStarted, "should be started now");
+ assertFalse(callback.gotLooped, "not looped yet");
+ assertFalse(callback.gotFinished, "not finished yet");
+ assertEquals(dataQueue, callback.lastEvent.getSource(), "check source of event");
+ assertEquals(sample, callback.lastEvent.getSequentialData(), "check sample");
+ assertEquals(2, callback.lastEvent.getLoopsLeft(), "check loopCount");
+
+ checkQueuedData(data, dataQueue, 1, data.length - 1);
+ dataQueue.firePendingCallbacks();
+ assertTrue(callback.gotLooped, "should be looped now");
+ assertEquals(1, callback.lastEvent.getLoopsLeft(), "check loopCount");
+ assertFalse(callback.gotFinished, "not finished yet");
+
+ checkQueuedData(data, dataQueue, 0, data.length);
+ dataQueue.firePendingCallbacks();
+ assertEquals(0, callback.lastEvent.getLoopsLeft(), "check loopCount");
+
+ checkQueuedData(data, dataQueue, 0, data.length);
+ dataQueue.firePendingCallbacks();
+ assertTrue(callback.gotFinished, "should be finished now");
+
+ assertFalse(dataQueue.hasMore(), "end empty");
+ }
+
+ @Test
+ public void testImmediate() {
+ float[] data = {
+ 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f
+ };
+ FloatSample sample = new FloatSample(data.length, 1);
+ sample.write(data);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ dataQueue.queue(sample);
+
+ // Only play some of the data then interrupt it with an immediate block.
+ checkQueuedData(data, dataQueue, 0, 3);
+
+ QueueDataCommand command = dataQueue.createQueueDataCommand(sample, 7, 3);
+ command.setImmediate(true);
+ command.run(); // execute "immediate" operation and add to block list
+
+ // Should already be in new data.
+ checkQueuedData(data, dataQueue, 7, 3);
+ }
+
+ @Test
+ public void testCrossFade() {
+ float[] data1 = {
+ 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f
+ };
+ float[] data2 = {
+ 20.0f, 19.0f, 18.0f, 17.0f, 16.0f, 15.0f, 14.0f, 13.0f, 12.0f, 11.0f
+ };
+ FloatSample sample1 = new FloatSample(data1);
+ FloatSample sample2 = new FloatSample(data2);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ dataQueue.queue(sample1, 0, 4);
+
+ QueueDataCommand command = dataQueue.createQueueDataCommand(sample2, 1, 8);
+ command.setCrossFadeIn(3);
+ command.run(); // execute "immediate" operation and add to block list
+
+ // Only play some of the data then crossfade to another sample.
+ checkQueuedData(data1, dataQueue, 0, 4);
+
+ for (int i = 0; i < 3; i++) {
+ double factor = i / 3.0;
+ double value = ((1.0 - factor) * data1[i + 4]) + (factor * data2[i + 1]);
+ LOGGER.debug("i = " + i + ", factor = " + factor + ", value = " + value);
+
+ double actual = dataQueue.readNextMonoDouble(synth.getFramePeriod());
+ assertEquals(value, actual, 0.00001, "crossfade " + i);
+ }
+
+ // Should already be in new data.
+ checkQueuedData(data2, dataQueue, 4, 5);
+ }
+
+ @Test
+ public void testImmediateCrossFade() {
+ float[] data1 = {
+ 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f
+ };
+ float[] data2 = {
+ 20.0f, 19.0f, 18.0f, 17.0f, 16.0f, 15.0f, 14.0f, 13.0f, 12.0f, 11.0f
+ };
+ FloatSample sample1 = new FloatSample(data1);
+ FloatSample sample2 = new FloatSample(data2);
+
+ UnitDataQueuePort dataQueue = new UnitDataQueuePort("test");
+ dataQueue.queue(sample1, 0, 4);
+
+ // Only play some of the data then crossfade to another sample.
+ int beforeInterrupt = 2;
+ checkQueuedData(data1, dataQueue, 0, beforeInterrupt);
+
+ QueueDataCommand command = dataQueue.createQueueDataCommand(sample2, 1, 8);
+ command.setImmediate(true);
+ command.setCrossFadeIn(3);
+ command.run(); // execute "immediate" operation and add to block list
+
+ for (int i = 0; i < 3; i++) {
+ double factor = i / 3.0;
+ double value = ((1.0 - factor) * data1[i + beforeInterrupt]) + (factor * data2[i + 1]);
+ LOGGER.debug("i = " + i + ", factor = " + factor + ", value = " + value);
+
+ double actual = dataQueue.readNextMonoDouble(synth.getFramePeriod());
+ assertEquals(value, actual, 0.00001, "crossfade " + i);
+ }
+
+ // Should already be in new data.
+ checkQueuedData(data2, dataQueue, 4, 5);
+ }
+}
diff --git a/src/test/java/com/jsyn/ports/TestSequentialData.java b/src/test/java/com/jsyn/ports/TestSequentialData.java
new file mode 100644
index 0000000..2f27ec2
--- /dev/null
+++ b/src/test/java/com/jsyn/ports/TestSequentialData.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009 Phil Burk, Mobileer Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.jsyn.ports;
+
+import com.jsyn.data.FloatSample;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TestSequentialData {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(TestSequentialData.class);
+
+ private final static float[] data1 = {
+ 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f
+ };
+
+ private final static float[] data2 = {
+ 20.0f, 19.0f, 18.0f, 17.0f, 16.0f, 15.0f, 14.0f, 13.0f, 12.0f, 11.0f
+ };
+
+ @Test
+ public void testCrossfade() {
+ var sample1 = new FloatSample(data1);
+ var sample2 = new FloatSample(data2);
+ SequentialDataCrossfade xfade = new SequentialDataCrossfade();
+ xfade.setup(sample1, 4, 3, sample2, 1, 6);
+
+ for (int i = 0; i < 3; i++) {
+ double factor = i / 3.0;
+ double value = ((1.0 - factor) * data1[i + 4]) + (factor * data2[i + 1]);
+ LOGGER.debug("i = " + i + ", factor = " + factor + ", value = " + value);
+ assertEquals(value, xfade.readDouble(i), 0.00001, "crossfade " + i);
+ }
+ for (int i = 3; i < 6; i++) {
+ assertEquals(sample2.readDouble(i + 1), xfade.readDouble(i), 0.00001, "crossfade " + i);
+ }
+ }
+}
diff --git a/src/test/java/com/jsyn/ports/TestSet.java b/src/test/java/com/jsyn/ports/TestSet.java
new file mode 100644
index 0000000..be426b7
--- /dev/null
+++ b/src/test/java/com/jsyn/ports/TestSet.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2009 Phil Burk, Mobileer Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.jsyn.ports;
+
+import com.jsyn.engine.SynthesisEngine;
+import com.jsyn.unitgen.Minimum;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+public class TestSet {
+
+ /** Internal value setting. */
+ @Test
+ public void testSetValue() {
+ int numParts = 4;
+ UnitInputPort port = new UnitInputPort(numParts, "Tester");
+ port.setValueInternal(0, 100.0);
+ port.setValueInternal(2, 120.0);
+ port.setValueInternal(1, 110.0);
+ port.setValueInternal(3, 130.0);
+ assertEquals(100.0, port.getValue(0), "check port value");
+ assertEquals(120.0, port.getValue(2), "check port value");
+ assertEquals(110.0, port.getValue(1), "check port value");
+ assertEquals(130.0, port.getValue(3), "check port value");
+ }
+
+ @Test
+ public void testSet() throws InterruptedException {
+ SynthesisEngine synthesisEngine = new SynthesisEngine();
+ synthesisEngine.setRealTime(false);
+ synthesisEngine.start();
+ synthesisEngine.sleepUntil(0.01);
+ Minimum min;
+ synthesisEngine.add(min = new Minimum());
+
+ double x = 33.99;
+ double y = 8.31;
+ min.inputA.set(x);
+ min.inputB.set(y);
+ synthesisEngine.sleepFor(0.01);
+ assertEquals(x, min.inputA.getValue(), "min set A");
+ assertEquals(y, min.inputB.getValue(), "min set B");
+ min.start();
+ synthesisEngine.sleepFor(0.01);
+
+ assertEquals(y, min.output.getValue(), "min output");
+ synthesisEngine.stop();
+ }
+
+ /** if we use a port index out of range we want to know now and not blow up the engine. */
+ @Test
+ public void testSetBadPort() throws InterruptedException {
+ SynthesisEngine synthesisEngine = new SynthesisEngine();
+ synthesisEngine.setRealTime(false);
+ synthesisEngine.start();
+ Minimum min;
+ synthesisEngine.add(min = new Minimum());
+
+ min.start();
+ try {
+ min.inputA.set(1, 23.45);
+ } catch (ArrayIndexOutOfBoundsException ignored) {
+ } catch (Exception e) {
+ fail("Catch port out of range, caught " + e);
+ }
+
+ // Don't blow up here.
+ synthesisEngine.sleepUntil(0.01);
+
+ synthesisEngine.stop();
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 06:51:16 +0000