Пример #1
0
        public void NuvoEssentiaCommandConstructor4Test()
        {
            string incomingCommand = "MPU_E6Dv1.23";
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);

            Assert.AreEqual(ENuvoEssentiaCommands.ReadVersion, target._command);
        }
Пример #2
0
        public void buildOutgoingCommand1Test()
        {
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(ENuvoEssentiaCommands.ReadVersion);
            string actual = target.buildOutgoingCommand();

            Assert.AreEqual("VER", actual);
        }
Пример #3
0
        public void NuvoEssentiaCommandConstructor1Test()
        {
            string incomingCommand = "Z02PWROFF,SRC4,GRP0,VOL-50";
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);

            Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusCONNECT, target._command);
        }
Пример #4
0
        public void NuvoEssentiaCommandConstructor3Test()
        {
            string incomingCommand = "IRSET:38,56,38,38,56,56";
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);

            Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusSOURCEIR, target._command);
        }
Пример #5
0
        public void buildOutgoingCommand5Test()
        {
            {
                NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor
                                                                (ENuvoEssentiaCommands.SetBassLevel, ENuvoEssentiaZones.Zone12, -10, 0); // ignore treble level
                string actual = target.buildOutgoingCommand();
                Assert.AreEqual("Z12BASS-10", actual);
            }

            {
                NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor
                                                                (ENuvoEssentiaCommands.SetBassLevel, ENuvoEssentiaZones.Zone12, 5, 0); // ignore treble level
                string actual = target.buildOutgoingCommand();
                Assert.AreEqual("Z12BASS+05", actual);
            }

            {
                NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor
                                                                (ENuvoEssentiaCommands.SetTrebleLevel, ENuvoEssentiaZones.Zone8, 5, 12); // ignore bass level
                string actual = target.buildOutgoingCommand();
                Assert.AreEqual("Z08TREB+12", actual);
            }

            {
                NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor
                                                                (ENuvoEssentiaCommands.SetTrebleLevel, ENuvoEssentiaZones.Zone9, 5, -12); // ignore bass level
                string actual = target.buildOutgoingCommand();
                Assert.AreEqual("Z09TREB-12", actual);
            }
        }
Пример #6
0
        public void NuvoEssentiaCommandConstructor2Test()
        {
            string incomingCommand = "Z04OR0,BASS+10,TREB-10,GRP0,VRST0";
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);

            Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusZONE, target._command);
        }
Пример #7
0
        public void buildOutgoingCommand3Test()
        {
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor
                                                            (ENuvoEssentiaCommands.SetSource, ENuvoEssentiaZones.Zone10, ENuvoEssentiaSources.Source2);
            string actual = target.buildOutgoingCommand();

            Assert.AreEqual("Z10SRC2", actual);
        }
Пример #8
0
        public void buildOutgoingCommand4Test()
        {
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor
                                                            (ENuvoEssentiaCommands.SetVolume, ENuvoEssentiaZones.Zone12, -60);
            string actual = target.buildOutgoingCommand();

            Assert.AreEqual("Z12VOL60", actual);
        }
Пример #9
0
        public void buildOutgoingCommand2Test()
        {
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor
                                                            (ENuvoEssentiaCommands.ReadStatusCONNECT, ENuvoEssentiaZones.Zone5);
            string actual = target.buildOutgoingCommand();

            Assert.AreEqual("Z05CONSR", actual);
        }
Пример #10
0
        public void replacePlaceholdersTest()
        {
            string actual = "";

            EIRCarrierFrequency[] ircf = { EIRCarrierFrequency.IRUnknown, EIRCarrierFrequency.IR38kHz, EIRCarrierFrequency.IR56kHz };
            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholders("IRSET:aa,bb,cc,dd,ee,ff", ENuvoEssentiaZones.NoZone, ENuvoEssentiaSources.NoSource, 0, 0, 0, EZonePowerStatus.ZoneStatusUnknown, ircf);
            Assert.AreEqual("IRSET:aa,38,56,dd,ee,ff", actual);
        }
Пример #11
0
        public void parseCommandForZoneTest()
        {
            string incomingCommand = "Z04PWRON,SRC2,GRP0,VOL-50";
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
            ENuvoEssentiaZones actual = NuvoEssentiaSingleCommand_Accessor.parseCommandForZone(incomingCommand, target._incomingCommandTemplate);

            Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusCONNECT, target._command);
            Assert.AreEqual(ENuvoEssentiaZones.Zone4, actual);
        }
Пример #12
0
        public void replacePlaceholderForZoneTest()
        {
            string actual = "";

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForZone("ZxxORp,BASSyy,TREByy,GRPq,VRSTr", ENuvoEssentiaZones.Zone1, "xx");
            Assert.AreEqual("Z01ORp,BASSyy,TREByy,GRPq,VRSTr", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForZone("ZxxORp,BASSyy,TREByy,GRPq,VRSTr", ENuvoEssentiaZones.Zone11, "xx");
            Assert.AreEqual("Z11ORp,BASSyy,TREByy,GRPq,VRSTr", actual);
        }
Пример #13
0
        public void replacePlaceholderForSourceTest()
        {
            string actual = "";

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForSource("XXXsXXXXsXXXX", ENuvoEssentiaSources.Source2, "s");
            Assert.AreEqual("XXX2XXXX2XXXX", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForSource("XXXssXXXXssXXXX", ENuvoEssentiaSources.Source4, "ss");
            Assert.AreEqual("XXX04XXXX04XXXX", actual);
        }
Пример #14
0
        public void replacePlaceholderForPowerStatusTest()
        {
            string actual = "";

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForPowerStatus("ZxxPWRppp,SRCs,GRPq,VOL-yy", EZonePowerStatus.ZoneStatusON, "ppp");
            Assert.AreEqual("ZxxPWRON,SRCs,GRPq,VOL-yy", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForPowerStatus("ZxxPWRppp,SRCs,GRPq,VOL-yy", EZonePowerStatus.ZoneStatusOFF, "ppp");
            Assert.AreEqual("ZxxPWROFF,SRCs,GRPq,VOL-yy", actual);
        }
Пример #15
0
        public void checkOutgoingCommandTest()
        {
            string emptyCommand = "Z02PWROFF,SRC4,GRP0,VOL-50";
            NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(emptyCommand);

            Assert.AreEqual(true, target.checkOutgoingCommand("EEEE"));
            Assert.AreEqual(false, target.checkOutgoingCommand("XXXwWWW"));
            Assert.AreEqual(true, target.checkOutgoingCommand("EEEE11111"));
            Assert.AreEqual(false, target.checkOutgoingCommand("XXXwWWW1111"));
            Assert.AreEqual(true, target.checkOutgoingCommand("EEEE11111_+()"));
            Assert.AreEqual(false, target.checkOutgoingCommand("XXXwWWW1111_+()"));
        }
Пример #16
0
        public void replacePlaceholderForIRFrequencyTest()
        {
            string actual = "";

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForIRFrequency("IRSET:aa,bb,cc,dd,ee,ff", EIRCarrierFrequency.IRUnknown, "bb");
            Assert.AreEqual("IRSET:aa,bb,cc,dd,ee,ff", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForIRFrequency("IRSET:aa,bb,cc,dd,ee,ff", EIRCarrierFrequency.IR38kHz, "bb");
            Assert.AreEqual("IRSET:aa,38,cc,dd,ee,ff", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderForIRFrequency("IRSET:aa,bb,cc,dd,ee,ff", EIRCarrierFrequency.IR56kHz, "bb");
            Assert.AreEqual("IRSET:aa,56,cc,dd,ee,ff", actual);
        }
Пример #17
0
        public void replacePlaceholderWithNumberConsideringPlusMinusTest()
        {
            string actual = "";

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithNumberConsideringPlusMinus("XXXtttXXX", 10, "ttt");
            Assert.AreEqual("XXX+10XXX", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithNumberConsideringPlusMinus("XXXtttXXX", -10, "ttt");
            Assert.AreEqual("XXX-10XXX", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithNumberConsideringPlusMinus("XXXtttXXX", 5, "ttt");
            Assert.AreEqual("XXX+05XXX", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithNumberConsideringPlusMinus("XXXtttXXX", -5, "ttt");
            Assert.AreEqual("XXX-05XXX", actual);
        }
Пример #18
0
        public void replacePlaceholderWithBassTrebleLevelTest()
        {
            string actual = "";

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithBassTrebleLevel("ZxxTREBttt", -10, "ttt");
            Assert.AreEqual("ZxxTREB-10", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithBassTrebleLevel("ZxxTREBttt", -12, "ttt");
            Assert.AreEqual("ZxxTREB-12", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithBassTrebleLevel("ZxxTREBttt", 5, "ttt");
            Assert.AreEqual("ZxxTREB+05", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithBassTrebleLevel("ZxxTREBttt", 13, "ttt");
            Assert.AreEqual("ZxxTREBttt", actual);
        }
Пример #19
0
        public void replacePlaceholderWithVolumeLevelTest()
        {
            string actual = "";

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithVolumeLevel("ZxxPWRppp,SRCs,GRPq,VOL-yy", -60, "yy");
            Assert.AreEqual("ZxxPWRppp,SRCs,GRPq,VOL-60", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithVolumeLevel("ZxxPWRppp,SRCs,GRPq,VOL-yy", -5, "yy");
            Assert.AreEqual("ZxxPWRppp,SRCs,GRPq,VOL-05", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithVolumeLevel("ZxxVOLyy", -5, "yy");
            Assert.AreEqual("ZxxVOL05", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.replacePlaceholderWithVolumeLevel("ZxxVOLyy", ZoneState.VALUE_UNDEFINED, "yy");
            Assert.AreEqual("ZxxVOLyy", actual);
        }
Пример #20
0
 public void parseCommandForVolumeLevelTest()
 {
     {
         string incomingCommand = "Z02PWROFF,SRC4,GRP0,VOL-50";
         NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
         int actualVolumeLevel = NuvoEssentiaSingleCommand_Accessor.parseCommandForVolumeLevel(incomingCommand, target._incomingCommandTemplate);
         Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusCONNECT, target._command);
         Assert.AreEqual(-50, actualVolumeLevel);
     }
     {
         string incomingCommand = "Z02PWROFF,SRC4,GRP0,VOL+50";  // invalid command
         NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
         int actualVolumeLevel = NuvoEssentiaSingleCommand_Accessor.parseCommandForVolumeLevel(incomingCommand, target._incomingCommandTemplate);
         Assert.AreEqual(ENuvoEssentiaCommands.NoCommand, target._command);
         Assert.AreEqual(ZoneState.VALUE_UNDEFINED, actualVolumeLevel);
         Assert.AreEqual(-999, actualVolumeLevel);
     }
 }
Пример #21
0
        public void parseCommandTest()
        {
            string actual;

            actual = NuvoEssentiaSingleCommand_Accessor.parseCommand("Z02OR0,BASS-08,TREB+10,GRP0,VRST0", "ZxxORp,BASSuuu,TREBttt,GRPq,VRSTr", "xx");
            Assert.AreEqual("02", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.parseCommand("Z02OR0,BASS-08,TREB+10,GRP0,VRST0", "ZxxORp,BASSuuu,TREBttt,GRPq,VRSTr", "uuu");
            Assert.AreEqual("-08", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.parseCommand("Z02OR0,BASS-08,TREB+10,GRP0,VRST0", "ZxxORp,BASSuuu,TREBttt,GRPq,VRSTr", "ttt");
            Assert.AreEqual("+10", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.parseCommand("Z02OR0,BASS-08,TREB+10,GRP0,VRST0", "ZxxORp,BASSuuu,TREBttt,GRPq,VRSTr", "q");
            Assert.AreEqual("0", actual);

            actual = NuvoEssentiaSingleCommand_Accessor.parseCommand("Z02OR0,BASS-08,TREB+10,GRP0,VRST5", "ZxxORp,BASSuuu,TREBttt,GRPq,VRSTr", "r");
            Assert.AreEqual("5", actual);
        }
Пример #22
0
 public void parseCommandForBassAndTrebleLevelTest()
 {
     {
         string incomingCommand = "Z03OR0,BASS-10,TREB+10,GRP0,VRST0";
         NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
         int actualBassLevel   = NuvoEssentiaSingleCommand_Accessor.parseCommandForBassLevel(incomingCommand, target._incomingCommandTemplate);
         int actualTrebleLevel = NuvoEssentiaSingleCommand_Accessor.parseCommandForTrebleLevel(incomingCommand, target._incomingCommandTemplate);
         Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusZONE, target._command);
         Assert.AreEqual(-10, actualBassLevel);
         Assert.AreEqual(10, actualTrebleLevel);
     }
     {
         string incomingCommand = "Z03OR0,BASS+05,TREB-04,GRP0,VRST0";
         NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
         int actualBassLevel   = NuvoEssentiaSingleCommand_Accessor.parseCommandForBassLevel(incomingCommand, target._incomingCommandTemplate);
         int actualTrebleLevel = NuvoEssentiaSingleCommand_Accessor.parseCommandForTrebleLevel(incomingCommand, target._incomingCommandTemplate);
         Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusZONE, target._command);
         Assert.AreEqual(5, actualBassLevel);
         Assert.AreEqual(-4, actualTrebleLevel);
     }
 }
Пример #23
0
 public void parseCommandForPowerStatusTest()
 {
     {
         string incomingCommand = "Z02PWROFF,SRC4,GRP0,VOL-50";
         NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
         EZonePowerStatus actual = NuvoEssentiaSingleCommand_Accessor.parseCommandForPowerStatus(incomingCommand, target._incomingCommandTemplate);
         Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusCONNECT, target._command);
         Assert.AreEqual(EZonePowerStatus.ZoneStatusOFF, actual);
     }
     {
         string incomingCommand = "Z02PWRON,SRC2,GRP0,VOL-50";
         NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
         EZonePowerStatus actual = NuvoEssentiaSingleCommand_Accessor.parseCommandForPowerStatus(incomingCommand, target._incomingCommandTemplate);
         Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusCONNECT, target._command);
         Assert.AreEqual(EZonePowerStatus.ZoneStatusON, actual);
     }
     {
         string incomingCommand = "Z02PWRxxx,SRC2,GRP0,VOL-50";
         NuvoEssentiaSingleCommand_Accessor target = new NuvoEssentiaSingleCommand_Accessor(incomingCommand);
         EZonePowerStatus actual = NuvoEssentiaSingleCommand_Accessor.parseCommandForPowerStatus(incomingCommand, target._incomingCommandTemplate);
         Assert.AreEqual(ENuvoEssentiaCommands.ReadStatusCONNECT, target._command);
         Assert.AreEqual(EZonePowerStatus.ZoneStatusUnknown, actual);
     }
 }