Question about EuTxManagerTest

[serim53]

안녕하세요.
EuTxManager 클래스를 Kotlin으로 리팩토링 진행하던 중,
테스트를 진행하다 알 수 없는 오류로 진행이 어려워 질문드립니다.

사진과 같이 테스트를 실행하면, 실행되지 않고 cancel이 되었다고 나옵니다.
기기의 문제인지, 코드 상 문제인지 알 수 없어 질문 드립니다.
해결방법이 있을까요?

[designe]

@serim53 테스트 코드와 해당 kotlin 코드를 공유해주시면 확인해볼 수 있을 것 같아요.

[serim53]

@serim53 테스트 코드와 해당 kotlin 코드를 공유해주시면 확인해볼 수 있을 것 같아요.

테스트코드

package co.euphony.tx;

import androidx.test.core.app.ApplicationProvider;
import androidx.test.filters.SmallTest;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.Arrays;

import co.euphony.util.EuOption;

import static org.junit.Assert.*;

@RunWith(Parameterized.class)
@SmallTest
public class EuTxManagerTest {
    private static final String TX_TAG = "EU_TXMANAGER_TAG";

    String code;
    String expectedASCIICode;
    String expectedGenCode;
    int expectedStreamLength;
    int expectedBufferLength;

    EuTxManager txManager = null;
    public EuTxManagerTest(String code, String asciiCode, String expectedGenCode, int expectedStreamLength, int expectedBufferLength) {
        this.code = code;
        this.expectedASCIICode = asciiCode;
        this.expectedGenCode = expectedGenCode;
        this.expectedStreamLength = expectedStreamLength;
        this.expectedBufferLength = expectedBufferLength;
    }

    @Before
    public void setup() {
        txManager = new EuTxManager();
    }

    @Test
    public void getCode() {
        txManager.setCode(code);

        String activeResult = txManager.getCode();
        assertEquals(expectedASCIICode, activeResult);
    }

    @Test
    public void getGenCode() {
        txManager.setCode(code);

        String activeResult = txManager.getGenCode();
        assertEquals(expectedGenCode, activeResult);
    }

    @Test
    public void setGetCodeTest() {
        txManager.setCode("a");
        String activeResult = txManager.getGenCode();
        assertEquals("S6197", activeResult);

        txManager.setCode("b");
        activeResult = txManager.getGenCode();
        assertEquals("S6284", activeResult);

    }

    @Test
    public void getGenWaveSource() {
        txManager.setCode(code);
        txManager.setMode(EuOption.ModeType.DEFAULT);
        float[] waveSourceData = txManager.getOutStream();
        assertEquals(waveSourceData.length, expectedStreamLength);
    }

    @Test
    public void testRun() {
        txManager.callEuPI(18000, EuTxManager.EuPIDuration.LENGTH_SHORT);
    }

    @Parameterized.Parameters
    public static Iterable<Object[]> data() {
        return Arrays.asList(new Object[][]{
                {"a", "61", "S6197", 5*2048, 5*8},
                {"b", "62", "S6284", 5*2048, 5*8},
                {"c", "63", "S6375", 5*2048, 5*8},
                {"abc", "616263", "S61626386", 9*2048, 9*8},
                {"Abc", "416263", "S416263a4", 9*2048, 9*8},
                {"lmno", "6c6d6e6f", "S6c6d6e6f20", 11*2048, 11*8},
                {"efg", "656667", "S656667c2", 9*2048, 9*8},
                {"abcdefghijklmnopqrstuvwxyz", "6162636465666768696a6b6c6d6e6f707172737475767778797a", "S6162636465666768696a6b6c6d6e6f707172737475767778797aaa", 55*2048, 55*8},
                {"ABC", "414243", "S414243e4", 9*2048, 9*8},
                {"ABCDEFGHIJKLMNOPQRSTUVWXYZ", "4142434445464748494a4b4c4d4e4f505152535455565758595a", "S4142434445464748494a4b4c4d4e4f505152535455565758595aea", 55*2048, 55*8},
        });
    }
}

[serim53]

@serim53 테스트 코드와 해당 kotlin 코드를 공유해주시면 확인해볼 수 있을 것 같아요.

코틀린코드 (EuTxManager.kt)

package co.euphony.tx

import android.content.Context
import android.media.AudioAttributes
import android.media.AudioFormat
import android.media.AudioManager
import android.media.AudioTrack
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.util.Log
import co.euphony.common.Constants
import co.euphony.common.EuNativeConnector
import co.euphony.util.EuOption.ModeType
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

class EuTxManager(
    private val txCore: EuNativeConnector = EuNativeConnector.getInstance(),
    private val context: Context? = null
) {
    private var audioTrack: AudioTrack? = null
    var modeType: ModeType? = null
        set(value) {
            txCore.setMode(value)
            field = value
        }
    private var playerEngineType: PlayerEngine? = null
    var code: String? = txCore.code
        set(value) {
            txCore.code = value
            field = value
        }

    enum class EuPIDuration {
        LENGTH_SHORT, LENGTH_LONG, LENGTH_FOREVER
    }

    enum class PlayerEngine {
        ANDROID_DEFAULT_ENGINE, EUPHONY_NATIVE_ENGINE
    }

    fun callEuPI(freq: Double, duration: EuPIDuration): Constants.Result? {
        modeType = ModeType.EUPI
        txCore.setToneOn(true)
        txCore.setAudioFrequency(freq)
        val res = txCore.tx_start()
        if (duration != EuPIDuration.LENGTH_FOREVER) {
            CoroutineScope(Dispatchers.IO).launch {
                delay(if (duration == EuPIDuration.LENGTH_SHORT) 200 else 500.toLong())
                stop()
            }
        }
        return res
    }

    fun getOutStream(): FloatArray? {
        return txCore.genWaveSource
    }

    fun getGenCode(): String? {
        return txCore.genCode
    }

    fun play() {
        play(1, PlayerEngine.ANDROID_DEFAULT_ENGINE)
    }

    fun play(count: Int) {
        play(count, PlayerEngine.ANDROID_DEFAULT_ENGINE)
    }

    fun play(count: Int, engineType: PlayerEngine) {
        playerEngineType = engineType
        modeType = ModeType.DEFAULT
        if (engineType == PlayerEngine.EUPHONY_NATIVE_ENGINE) {
            playWithNativeEngine(count)
        } else {
            playWithAndroidEngine(count)
        }
    }

    private fun playWithNativeEngine(count: Int) {
        txCore.setCountToneOn(true, count)
        txCore.tx_start()
    }

    private fun playWithAndroidEngine(count: Int) {
        var loopCount = count
        val outStream = txCore.genWaveSource
        val minBufferSizeBytes = AudioTrack.getMinBufferSize(
            Constants.SAMPLERATE,
            AudioFormat.CHANNEL_OUT_MONO,
            AudioFormat.ENCODING_PCM_FLOAT
        )
        val bufferSize = outStream.size * minBufferSizeBytes
        audioTrack = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            AudioTrack.Builder()
                .apply {
                    setAudioFormat(AudioFormat.Builder().apply {
                        setChannelMask(AudioFormat.CHANNEL_OUT_MONO)
                        setSampleRate(Constants.SAMPLERATE)
                        setEncoding(AudioFormat.ENCODING_PCM_FLOAT)
                    }.build())
                    setAudioAttributes(AudioAttributes.Builder().apply {
                        setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                    }.build())
                    setBufferSizeInBytes(bufferSize)
                    setTransferMode(AudioTrack.MODE_STATIC)
                }.build()
        } else {
            AudioTrack(
                AudioManager.STREAM_MUSIC,
                Constants.SAMPLERATE,
                AudioFormat.CHANNEL_OUT_MONO,
                AudioFormat.ENCODING_PCM_FLOAT,
                bufferSize,
                AudioTrack.MODE_STATIC
            )
        }

        /* A value of -1 means infinite looping, and 0 disables looping. */
        if (loopCount <= 0) loopCount = -1
        val result = audioTrack!!.setLoopPoints(0, outStream.size, loopCount)
        if (result != AudioTrack.SUCCESS) {
            Log.i("PROCESS", "failed to loop points : $result")
        }

        audioTrack?.let {
            try {
                it.write(outStream, 0, outStream.size, AudioTrack.WRITE_NON_BLOCKING)
                it.play()
            } catch (e: IllegalStateException) {
                Log.i("PROCESS", e.message!!)
            }
        }
    }

    fun stop() {
        if (modeType == ModeType.DEFAULT && playerEngineType == PlayerEngine.ANDROID_DEFAULT_ENGINE) {
            audioTrack?.pause()
        } else {
            txCore.tx_stop()
        }
    }

    /*
	 * @deprecated Replaced by {@link #setModeType(String)}, deprecated for naming & dynamic option.
	 */
    @Deprecated("", ReplaceWith("setModeType(type)"))
    fun setMode(type: ModeType?) {
        modeType = type
    }

    /*
	 * @deprecated Replaced by {@link #setCode(String)}, deprecated for naming & dynamic option.
	 */
    @Deprecated("", ReplaceWith("setCode(data)"))
    fun euInitTransmit(data: String?) {
        code = data
    }

    /*
	 * @deprecated Replaced by {@link #play()}, deprecated for naming issue
	 */
    @Deprecated(
        "", ReplaceWith(
            "play(1, PlayerEngine.ANDROID_DEFAULT_ENGINE)",
            "co.euphony.tx.EuTxManager1.PlayerEngine"
        )
    )
    fun process() {
        play(1, PlayerEngine.ANDROID_DEFAULT_ENGINE)
    }

    /*
	 * @deprecated Replaced by {@link #play(int)}, deprecated for naming issue
	 */
    @Deprecated(
        "", ReplaceWith(
            "play(count, PlayerEngine.ANDROID_DEFAULT_ENGINE)",
            "co.euphony.tx.EuTxManager1.PlayerEngine"
        )
    )
    fun process(count: Int) {
        play(count, PlayerEngine.ANDROID_DEFAULT_ENGINE)
    }
}

[designe]

@serim53 돌려보는게 확실한데 제가 지금 컴퓨터가 없어서 바로 확인이 안될것 같네요 ㅠ

체크해봐야 할 것은

• kotlin 코드 전 기존 EuTxManager java 코드는 unit test가 잘 동작했는지?
• 잘 동작하지 않았다면 기존 유닛 테스트 점검이 필요할 것 같고
• 잘 동작했다면 유닛테스트 함수 하나하나 제거해나가면서 비정상동작하는 테스트 함수를 찾아 작성하신 코틀린 함수 수정이 필요할 것 같아요.

최근 v8.1 이후로 gradle 버전이 4.3.3 에서 7.3.3으로 바뀌면서 이후에 java쪽 유닛테스트 검증이 안됐는데 점검이 필요할 수 있을 것 같아요.

[yeonns]

@serim53 @designe

• kotlin 코드 전 기존 EuTxManagerTest 코드는 정상동작합니다
• 기존 EuTxManager.java를 android studio를 통해 자동으로 kt 변환시킨 후, 테스트 코드를 돌리면 정상동작합니다

아무래도 세림님이 kotlin으로 변환한 코드 중 문제를 일으키는 부분이 있는것같은데 원인은 현재 파악중에 있습니다

[serim53]

확인해보니 txCore.code를 받아오는 중에 get 함수를 사용하지 않고 직접적으로 인입해주어 생긴 문제였던 것 같습니다!
현재 해결해서 PR 올려놓았습니다! 도움주셔서 감사합니다! ☺️