Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c2b6a6bc authored by Mikhail Naganov's avatar Mikhail Naganov
Browse files

Enable clang format hook for media/libaudioclient/tests 

Apply formatting to existing tests.

Test: N/A
Change-Id: I2818bb58d416313aa020778923d025a8f5e563ea
parent 9cfb9252

PREUPLOAD.cfg

+1 −0
Original line number Diff line number Diff line
@@ -11,3 +11,4 @@ clang_format = true 
clang_format = --commit ${PREUPLOAD_COMMIT} --style file --extensions c,h,cc,cpp

               media/libmediatranscoding/

               services/mediatranscoding/

               media/libaudioclient/tests/

media/libaudioclient/tests/audio_aidl_legacy_conversion_tests.cpp

+54 −57
Original line number Diff line number Diff line
@@ -16,8 +16,8 @@ 


#include <gtest/gtest.h>



#include <media/AudioCommonTypes.h>

#include <media/AidlConversion.h>

#include <media/AudioCommonTypes.h>



using namespace android;

using namespace android::aidl_utils;
@@ -31,7 +31,8 @@ using media::audio::common::PcmType; 


namespace {



template<typename T> size_t hash(const T& t) {

template <typename T>

size_t hash(const T& t) {

    return std::hash<T>{}(t);

}
@@ -52,10 +53,8 @@ AudioChannelLayout make_ACL_LayoutArbitrary() { 
    return AudioChannelLayout::make<AudioChannelLayout::Tag::layoutMask>(

            // Use channels that exist both for input and output,

            // but doesn't form a known layout mask.

            AudioChannelLayout::CHANNEL_FRONT_LEFT |

            AudioChannelLayout::CHANNEL_FRONT_RIGHT |

            AudioChannelLayout::CHANNEL_TOP_SIDE_LEFT |

            AudioChannelLayout::CHANNEL_TOP_SIDE_RIGHT);

            AudioChannelLayout::CHANNEL_FRONT_LEFT | AudioChannelLayout::CHANNEL_FRONT_RIGHT |

            AudioChannelLayout::CHANNEL_TOP_SIDE_LEFT | AudioChannelLayout::CHANNEL_TOP_SIDE_RIGHT);

}



AudioChannelLayout make_ACL_ChannelIndex2() {
@@ -121,8 +120,7 @@ AudioFormatDescription make_AudioFormatDescription(const std::string& encoding) 
    return result;

}



AudioFormatDescription make_AudioFormatDescription(PcmType transport,

        const std::string& encoding) {

AudioFormatDescription make_AudioFormatDescription(PcmType transport, const std::string& encoding) {

    auto result = make_AudioFormatDescription(encoding);

    result.pcm = transport;

    return result;
@@ -163,7 +161,8 @@ AudioFormatDescription make_AFD_Encap_with_Enc() { 
// is identical to the same format description constructed by the framework.

class HashIdentityTest : public ::testing::Test {

  public:

    template<typename T> void verifyHashIdentity(const std::vector<std::function<T()>>& valueGens) {

    template <typename T>

    void verifyHashIdentity(const std::vector<std::function<T()>>& valueGens) {

        for (size_t i = 0; i < valueGens.size(); ++i) {

            for (size_t j = 0; j < valueGens.size(); ++j) {

                if (i == j) {
@@ -177,27 +176,25 @@ class HashIdentityTest : public ::testing::Test { 
};



TEST_F(HashIdentityTest, AudioChannelLayoutHashIdentity) {

    verifyHashIdentity<AudioChannelLayout>({

            make_ACL_None, make_ACL_Invalid, make_ACL_Stereo,

    verifyHashIdentity<AudioChannelLayout>({make_ACL_None, make_ACL_Invalid, make_ACL_Stereo,

                                            make_ACL_LayoutArbitrary, make_ACL_ChannelIndex2,

                                            make_ACL_ChannelIndexArbitrary, make_ACL_VoiceCall});

}



TEST_F(HashIdentityTest, AudioDeviceDescriptionHashIdentity) {

    verifyHashIdentity<AudioDeviceDescription>({

            make_ADD_None, make_ADD_DefaultIn, make_ADD_DefaultOut, make_ADD_WiredHeadset,

    verifyHashIdentity<AudioDeviceDescription>({make_ADD_None, make_ADD_DefaultIn,

                                                make_ADD_DefaultOut, make_ADD_WiredHeadset,

                                                make_ADD_BtScoHeadset});

}



TEST_F(HashIdentityTest, AudioFormatDescriptionHashIdentity) {

    verifyHashIdentity<AudioFormatDescription>({

            make_AFD_Default, make_AFD_Invalid, make_AFD_Pcm16Bit, make_AFD_Bitstream,

    verifyHashIdentity<AudioFormatDescription>({make_AFD_Default, make_AFD_Invalid,

                                                make_AFD_Pcm16Bit, make_AFD_Bitstream,

                                                make_AFD_Encap, make_AFD_Encap_with_Enc});

}



using ChannelLayoutParam = std::tuple<AudioChannelLayout, bool /*isInput*/>;

class AudioChannelLayoutRoundTripTest :

        public testing::TestWithParam<ChannelLayoutParam> {};

class AudioChannelLayoutRoundTripTest : public testing::TestWithParam<ChannelLayoutParam> {};

TEST_P(AudioChannelLayoutRoundTripTest, Aidl2Legacy2Aidl) {

    const auto initial = std::get<0>(GetParam());

    const bool isInput = std::get<1>(GetParam());
@@ -207,21 +204,20 @@ TEST_P(AudioChannelLayoutRoundTripTest, Aidl2Legacy2Aidl) { 
    ASSERT_TRUE(convBack.ok());

    EXPECT_EQ(initial, convBack.value());

}

INSTANTIATE_TEST_SUITE_P(AudioChannelLayoutRoundTrip,

        AudioChannelLayoutRoundTripTest,

        testing::Combine(

                testing::Values(AudioChannelLayout{}, make_ACL_Invalid(), make_ACL_Stereo(),

                        make_ACL_LayoutArbitrary(), make_ACL_ChannelIndex2(),

INSTANTIATE_TEST_SUITE_P(AudioChannelLayoutRoundTrip, AudioChannelLayoutRoundTripTest,

                         testing::Combine(testing::Values(AudioChannelLayout{}, make_ACL_Invalid(),

                                                          make_ACL_Stereo(),

                                                          make_ACL_LayoutArbitrary(),

                                                          make_ACL_ChannelIndex2(),

                                                          make_ACL_ChannelIndexArbitrary()),

                                          testing::Values(false, true)));

INSTANTIATE_TEST_SUITE_P(AudioChannelVoiceRoundTrip,

        AudioChannelLayoutRoundTripTest,

INSTANTIATE_TEST_SUITE_P(AudioChannelVoiceRoundTrip, AudioChannelLayoutRoundTripTest,

                         // In legacy constants the voice call is only defined for input.

        testing::Combine(testing::Values(make_ACL_VoiceCall()), testing::Values(true)));

                         testing::Combine(testing::Values(make_ACL_VoiceCall()),

                                          testing::Values(true)));



using ChannelLayoutEdgeCaseParam = std::tuple<int /*legacy*/, bool /*isInput*/, bool /*isValid*/>;

class AudioChannelLayoutEdgeCaseTest :

        public testing::TestWithParam<ChannelLayoutEdgeCaseParam> {};

class AudioChannelLayoutEdgeCaseTest : public testing::TestWithParam<ChannelLayoutEdgeCaseParam> {};

TEST_P(AudioChannelLayoutEdgeCaseTest, Legacy2Aidl) {

    const audio_channel_mask_t legacy = static_cast<audio_channel_mask_t>(std::get<0>(GetParam()));

    const bool isInput = std::get<1>(GetParam());
@@ -229,8 +225,8 @@ TEST_P(AudioChannelLayoutEdgeCaseTest, Legacy2Aidl) { 
    auto conv = legacy2aidl_audio_channel_mask_t_AudioChannelLayout(legacy, isInput);

    EXPECT_EQ(isValid, conv.ok());

}

INSTANTIATE_TEST_SUITE_P(AudioChannelLayoutEdgeCase,

        AudioChannelLayoutEdgeCaseTest,

INSTANTIATE_TEST_SUITE_P(

        AudioChannelLayoutEdgeCase, AudioChannelLayoutEdgeCaseTest,

        testing::Values(

                // Valid legacy input masks.

                std::make_tuple(AUDIO_CHANNEL_IN_VOICE_UPLINK_MONO, true, true),
@@ -240,25 +236,26 @@ INSTANTIATE_TEST_SUITE_P(AudioChannelLayoutEdgeCase, 
                std::make_tuple(

                        // This has the same numerical representation as Mask 'A' below

                        AUDIO_CHANNEL_OUT_FRONT_CENTER | AUDIO_CHANNEL_OUT_LOW_FREQUENCY |

                        AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT, false, true),

                                AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT,

                        false, true),

                std::make_tuple(

                        // This has the same numerical representation as Mask 'B' below

                        AUDIO_CHANNEL_OUT_FRONT_CENTER | AUDIO_CHANNEL_OUT_LOW_FREQUENCY |

                        AUDIO_CHANNEL_OUT_TOP_BACK_LEFT, false, true),

                                AUDIO_CHANNEL_OUT_TOP_BACK_LEFT,

                        false, true),

                // Invalid legacy input masks.

                std::make_tuple(AUDIO_CHANNEL_IN_6, true, false),

                std::make_tuple(

                        AUDIO_CHANNEL_IN_6 | AUDIO_CHANNEL_IN_FRONT_PROCESSED, true, false),

                std::make_tuple(

                        AUDIO_CHANNEL_IN_PRESSURE | AUDIO_CHANNEL_IN_X_AXIS |

                        AUDIO_CHANNEL_IN_Y_AXIS | AUDIO_CHANNEL_IN_Z_AXIS, true, false),

                std::make_tuple(AUDIO_CHANNEL_IN_6 | AUDIO_CHANNEL_IN_FRONT_PROCESSED, true, false),

                std::make_tuple(AUDIO_CHANNEL_IN_PRESSURE | AUDIO_CHANNEL_IN_X_AXIS |

                                        AUDIO_CHANNEL_IN_Y_AXIS | AUDIO_CHANNEL_IN_Z_AXIS,

                                true, false),

                std::make_tuple(  // Mask 'A'

                        AUDIO_CHANNEL_IN_STEREO | AUDIO_CHANNEL_IN_VOICE_UPLINK, true, false),

                std::make_tuple(  // Mask 'B'

                        AUDIO_CHANNEL_IN_STEREO | AUDIO_CHANNEL_IN_VOICE_DNLINK, true, false)));



class AudioDeviceDescriptionRoundTripTest :

        public testing::TestWithParam<AudioDeviceDescription> {};

class AudioDeviceDescriptionRoundTripTest : public testing::TestWithParam<AudioDeviceDescription> {

};

TEST_P(AudioDeviceDescriptionRoundTripTest, Aidl2Legacy2Aidl) {

    const auto initial = GetParam();

    auto conv = aidl2legacy_AudioDeviceDescription_audio_devices_t(initial);
@@ -267,13 +264,13 @@ TEST_P(AudioDeviceDescriptionRoundTripTest, Aidl2Legacy2Aidl) { 
    ASSERT_TRUE(convBack.ok());

    EXPECT_EQ(initial, convBack.value());

}

INSTANTIATE_TEST_SUITE_P(AudioDeviceDescriptionRoundTrip,

        AudioDeviceDescriptionRoundTripTest,

INSTANTIATE_TEST_SUITE_P(AudioDeviceDescriptionRoundTrip, AudioDeviceDescriptionRoundTripTest,

                         testing::Values(AudioDeviceDescription{}, make_ADD_DefaultIn(),

                make_ADD_DefaultOut(), make_ADD_WiredHeadset(), make_ADD_BtScoHeadset()));

                                         make_ADD_DefaultOut(), make_ADD_WiredHeadset(),

                                         make_ADD_BtScoHeadset()));



class AudioFormatDescriptionRoundTripTest :

        public testing::TestWithParam<AudioFormatDescription> {};

class AudioFormatDescriptionRoundTripTest : public testing::TestWithParam<AudioFormatDescription> {

};

TEST_P(AudioFormatDescriptionRoundTripTest, Aidl2Legacy2Aidl) {

    const auto initial = GetParam();

    auto conv = aidl2legacy_AudioFormatDescription_audio_format_t(initial);
@@ -282,6 +279,6 @@ TEST_P(AudioFormatDescriptionRoundTripTest, Aidl2Legacy2Aidl) { 
    ASSERT_TRUE(convBack.ok());

    EXPECT_EQ(initial, convBack.value());

}

INSTANTIATE_TEST_SUITE_P(AudioFormatDescriptionRoundTrip,

        AudioFormatDescriptionRoundTripTest,

        testing::Values(make_AFD_Invalid(), AudioFormatDescription{}, make_AFD_Pcm16Bit()));
 
INSTANTIATE_TEST_SUITE_P(AudioFormatDescriptionRoundTrip, AudioFormatDescriptionRoundTripTest,

                         testing::Values(make_AFD_Invalid(), AudioFormatDescription{},

                                         make_AFD_Pcm16Bit()));

media/libaudioclient/tests/audio_aidl_status_tests.cpp

+21 −54
Original line number Diff line number Diff line
@@ -37,25 +37,10 @@ TEST(audio_aidl_status_tests, statusRoundTripSmallValues) { 


// Special status values are preserved on round trip.

TEST(audio_aidl_status_tests, statusRoundTripSpecialValues) {

    for (status_t status : {

            OK,

            UNKNOWN_ERROR,

            NO_MEMORY,

            INVALID_OPERATION,

            BAD_VALUE,

            BAD_TYPE,

            NAME_NOT_FOUND,

            PERMISSION_DENIED,

            NO_INIT,

            ALREADY_EXISTS,

            DEAD_OBJECT,

            FAILED_TRANSACTION,

            BAD_INDEX,

            NOT_ENOUGH_DATA,

            WOULD_BLOCK,

            TIMED_OUT,

            UNKNOWN_TRANSACTION,

            FDS_NOT_ALLOWED}) {

    for (status_t status :

         {OK, UNKNOWN_ERROR, NO_MEMORY, INVALID_OPERATION, BAD_VALUE, BAD_TYPE, NAME_NOT_FOUND,

          PERMISSION_DENIED, NO_INIT, ALREADY_EXISTS, DEAD_OBJECT, FAILED_TRANSACTION, BAD_INDEX,

          NOT_ENOUGH_DATA, WOULD_BLOCK, TIMED_OUT, UNKNOWN_TRANSACTION, FDS_NOT_ALLOWED}) {

        ASSERT_EQ(status, statusTFromBinderStatus(binderStatusFromStatusT(status)));

    }

}
@@ -64,12 +49,8 @@ TEST(audio_aidl_status_tests, statusRoundTripSpecialValues) { 
TEST(audio_aidl_status_tests, binderStatusExceptions) {

    for (int exceptionCode : {

                 // Status::EX_NONE,

            Status::EX_SECURITY,

            Status::EX_BAD_PARCELABLE,

            Status::EX_ILLEGAL_ARGUMENT,

            Status::EX_NULL_POINTER,

            Status::EX_ILLEGAL_STATE,

            Status::EX_NETWORK_MAIN_THREAD,

                 Status::EX_SECURITY, Status::EX_BAD_PARCELABLE, Status::EX_ILLEGAL_ARGUMENT,

                 Status::EX_NULL_POINTER, Status::EX_ILLEGAL_STATE, Status::EX_NETWORK_MAIN_THREAD,

                 Status::EX_UNSUPPORTED_OPERATION,

                 // Status::EX_SERVICE_SPECIFIC, -- tested fromServiceSpecificError()

                 Status::EX_PARCELABLE,
@@ -85,25 +66,11 @@ TEST(audio_aidl_status_tests, binderStatusExceptions) { 


// Binder transaction errors show exactly in status_t; these come fromStatusT().

TEST(audio_aidl_status_tests, binderStatusTransactionError) {

    for (status_t status : {

            OK, // Note: fromStatusT does check if this is 0, so this is no error.

            UNKNOWN_ERROR,

            NO_MEMORY,

            INVALID_OPERATION,

            BAD_VALUE,

            BAD_TYPE,

            NAME_NOT_FOUND,

            PERMISSION_DENIED,

            NO_INIT,

            ALREADY_EXISTS,

            DEAD_OBJECT,

            FAILED_TRANSACTION,

            BAD_INDEX,

            NOT_ENOUGH_DATA,

            WOULD_BLOCK,

            TIMED_OUT,

            UNKNOWN_TRANSACTION,

            FDS_NOT_ALLOWED}) {

    for (status_t status :

         {OK,  // Note: fromStatusT does check if this is 0, so this is no error.

          UNKNOWN_ERROR, NO_MEMORY, INVALID_OPERATION, BAD_VALUE, BAD_TYPE, NAME_NOT_FOUND,

          PERMISSION_DENIED, NO_INIT, ALREADY_EXISTS, DEAD_OBJECT, FAILED_TRANSACTION, BAD_INDEX,

          NOT_ENOUGH_DATA, WOULD_BLOCK, TIMED_OUT, UNKNOWN_TRANSACTION, FDS_NOT_ALLOWED}) {

        ASSERT_EQ(status, statusTFromBinderStatus(Status::fromStatusT(status)));

    }

}

media/libaudioclient/tests/test_create_audiorecord.cpp

+15 −33
Original line number Diff line number Diff line
@@ -35,8 +35,7 @@ namespace android { 


using android::content::AttributionSourceState;



int testRecord(FILE *inputFile, int outputFileFd)

{

int testRecord(FILE* inputFile, int outputFileFd) {

    char line[MAX_INPUT_FILE_LINE_LENGTH];

    uint32_t testCount = 0;

    Vector<String16> args;
@@ -47,11 +46,9 @@ int testRecord(FILE *inputFile, int outputFileFd) 
    attributionSource.token = sp<BBinder>::make();



    if (inputFile == nullptr) {

        sp<AudioRecord> record = new AudioRecord(AUDIO_SOURCE_DEFAULT,

                                              0 /* sampleRate */,

                                              AUDIO_FORMAT_DEFAULT,

                                              AUDIO_CHANNEL_IN_MONO,

                                              attributionSource);

        sp<AudioRecord> record =

                new AudioRecord(AUDIO_SOURCE_DEFAULT, 0 /* sampleRate */, AUDIO_FORMAT_DEFAULT,

                                AUDIO_CHANNEL_IN_MONO, attributionSource);

        if (record == 0 || record->initCheck() != NO_ERROR) {

            write(outputFileFd, "Error creating AudioRecord\n",

                  sizeof("Error creating AudioRecord\n"));
@@ -80,10 +77,9 @@ int testRecord(FILE *inputFile, int outputFileFd) 
        char statusStr[MAX_OUTPUT_FILE_LINE_LENGTH];

        bool fast = false;



        if (sscanf(line, " %u %x %x %zu %d %x %u %u",

                   &sampleRate, &format, &channelMask,

                   &frameCount, &notificationFrames,

                   &flags, &sessionId, &inputSource) != NUM_ARGUMENTS) {

        if (sscanf(line, " %u %x %x %zu %d %x %u %u", &sampleRate, &format, &channelMask,

                   &frameCount, &notificationFrames, &flags, &sessionId,

                   &inputSource) != NUM_ARGUMENTS) {

            fprintf(stderr, "Malformed line for test #%u in input file\n", testCount + 1);

            ret = 1;

            continue;
@@ -100,21 +96,10 @@ int testRecord(FILE *inputFile, int outputFileFd) 
        sp<AudioRecord> record = new AudioRecord(attributionSource);

        const auto emptyCallback = sp<AudioRecord::IAudioRecordCallback>::make();



        record->set(AUDIO_SOURCE_DEFAULT,

                   sampleRate,

                   format,

                   channelMask,

                   frameCount,

                   fast ? emptyCallback : nullptr,

                   notificationFrames,

                   false,

                   sessionId,

                   fast ? AudioRecord::TRANSFER_CALLBACK : AudioRecord::TRANSFER_DEFAULT,

                   flags,

                   getuid(),

                   getpid(),

                   &attributes,

                   AUDIO_PORT_HANDLE_NONE);

        record->set(AUDIO_SOURCE_DEFAULT, sampleRate, format, channelMask, frameCount,

                    fast ? emptyCallback : nullptr, notificationFrames, false, sessionId,

                    fast ? AudioRecord::TRANSFER_CALLBACK : AudioRecord::TRANSFER_DEFAULT, flags,

                    getuid(), getpid(), &attributes, AUDIO_PORT_HANDLE_NONE);

        status = record->initCheck();

        sprintf(statusStr, "\n#### Test %u status %d\n", testCount, status);

        write(outputFileFd, statusStr, strlen(statusStr));
@@ -128,9 +113,6 @@ int testRecord(FILE *inputFile, int outputFileFd) 


};  // namespace android





int main(int argc, char **argv)

{

int main(int argc, char** argv) {

    return android::main(argc, argv, android::testRecord);

}

media/libaudioclient/tests/test_create_audiotrack.cpp

+17 −36
Original line number Diff line number Diff line
@@ -32,18 +32,15 @@ 


namespace android {



int testTrack(FILE *inputFile, int outputFileFd)

{

int testTrack(FILE* inputFile, int outputFileFd) {

    char line[MAX_INPUT_FILE_LINE_LENGTH];

    uint32_t testCount = 0;

    Vector<String16> args;

    int ret = 0;



    if (inputFile == nullptr) {

        sp<AudioTrack> track = new AudioTrack(AUDIO_STREAM_DEFAULT,

                                              0 /* sampleRate */,

                                              AUDIO_FORMAT_DEFAULT,

                                              AUDIO_CHANNEL_OUT_STEREO);

        sp<AudioTrack> track = new AudioTrack(AUDIO_STREAM_DEFAULT, 0 /* sampleRate */,

                                              AUDIO_FORMAT_DEFAULT, AUDIO_CHANNEL_OUT_STEREO);

        if (track == 0 || track->initCheck() != NO_ERROR) {

            write(outputFileFd, "Error creating AudioTrack\n",

                  sizeof("Error creating AudioTrack\n"));
@@ -78,10 +75,9 @@ int testTrack(FILE *inputFile, int outputFileFd) 
        bool offload = false;

        bool fast = false;



        if (sscanf(line, " %u %x %x %zu %d %u %x %u %u %u",

                   &sampleRate, &format, &channelMask,

                   &frameCount, &notificationFrames, &useSharedBuffer,

                   &flags, &sessionId, &usage, &contentType) != NUM_ARGUMENTS) {

        if (sscanf(line, " %u %x %x %zu %d %u %x %u %u %u", &sampleRate, &format, &channelMask,

                   &frameCount, &notificationFrames, &useSharedBuffer, &flags, &sessionId, &usage,

                   &contentType) != NUM_ARGUMENTS) {

            fprintf(stderr, "Malformed line for test #%u in input file\n", testCount + 1);

            ret = 1;

            continue;
@@ -111,25 +107,13 @@ int testTrack(FILE *inputFile, int outputFileFd) 
        attributes.usage = usage;

        sp<AudioTrack> track = new AudioTrack();

        const auto emptyCallback = sp<AudioTrack::IAudioTrackCallback>::make();

        track->set(AUDIO_STREAM_DEFAULT,

                   sampleRate,

                   format,

                   channelMask,

                   frameCount,

                   flags,

                   (fast || offload) ? emptyCallback : nullptr,

                   notificationFrames,

                   sharedBuffer,

                   false,

                   sessionId,

                   ((fast && sharedBuffer == 0) || offload) ?

                           AudioTrack::TRANSFER_CALLBACK : AudioTrack::TRANSFER_DEFAULT,

                   offload ? &offloadInfo : nullptr,

                   AttributionSourceState(),

                   &attributes,

                   false,

                   1.0f,

                   AUDIO_PORT_HANDLE_NONE);

        track->set(AUDIO_STREAM_DEFAULT, sampleRate, format, channelMask, frameCount, flags,

                   (fast || offload) ? emptyCallback : nullptr, notificationFrames, sharedBuffer,

                   false, sessionId,

                   ((fast && sharedBuffer == 0) || offload) ? AudioTrack::TRANSFER_CALLBACK

                                                            : AudioTrack::TRANSFER_DEFAULT,

                   offload ? &offloadInfo : nullptr, AttributionSourceState(), &attributes, false,

                   1.0f, AUDIO_PORT_HANDLE_NONE);

        status = track->initCheck();

        sprintf(statusStr, "\n#### Test %u status %d\n", testCount, status);

        write(outputFileFd, statusStr, strlen(statusStr));
@@ -143,9 +127,6 @@ int testTrack(FILE *inputFile, int outputFileFd) 


};  // namespace android





int main(int argc, char **argv)

{

int main(int argc, char** argv) {

    return android::main(argc, argv, android::testTrack);

}