示例#1
0
        public void RecordingConfigurationInvalidTokenTest()
        {
            string token = null;

            RunTest(() =>
            {
                GetRecordingsResponseItem[] recordings = GetRecordings();

                if (recordings == null || recordings.Length == 0)
                {
                    RecordingConfiguration config = new RecordingConfiguration();
                    config.MaximumRetentionTime   = _retentionTime;
                    config.Content            = "Recording from device";
                    config.Source             = new RecordingSourceInformation();
                    config.Source.SourceId    = CameraAddress.Trim();
                    config.Source.Name        = "CameraName";
                    config.Source.Location    = "LocationDescription";
                    config.Source.Description = "SourceDescription";
                    config.Source.Address     = CameraAddress.Trim();

                    token = CreateRecording(config);
                }

                this.InvalidTokenTestBody((s) => Client.GetRecordingConfiguration(s),
                                          RunStep, "Recording Configuration", OnvifFaults.NoRecording);
            },
                    () =>
            {
                if (token != null)
                {
                    DeleteRecording(token);
                }
            });
        }
        public void Start()
        {
            _mjpegDecoder.FrameReady += MjpegDecoderFrameReady;


            if (CameraAddress != null && !CameraAddress.IsWellFormedOriginalString())
            {
                return;
            }


            try
            {
                _mjpegDecoder.ParseStream(CameraAddress, Username, Password);
                IsRunning = true;
            }
            catch (Exception)
            {
                IsRunning = false;
                Stop();
            }
        }
示例#3
0
        public void GetTrackConfigurationInvalidTokenTest()
        {
            string recordingToken = string.Empty;
            bool   isCreated      = false;

            RunTest(() =>
            {
                var recordings    = GetRecordings();
                string trackToken = string.Empty;

                if (recordings == null || recordings.Length == 0)
                {
                    RecordingConfiguration config = new RecordingConfiguration();
                    config.MaximumRetentionTime   = "PT0S";
                    config.Content            = "Recording from device";
                    config.Source             = new RecordingSourceInformation();
                    config.Source.SourceId    = CameraAddress.Trim();
                    config.Source.Name        = "CameraName";
                    config.Source.Location    = "LocationDescription";
                    config.Source.Description = "SourceDescription";
                    config.Source.Address     = CameraAddress.Trim();
                    try
                    {
                        recordingToken = CreateRecording(config);
                    }
                    catch (FaultException ex)
                    {
                        LogStepEvent(ex.Message);
                        StepPassed();
                        return;
                    }

                    Assert(!string.IsNullOrEmpty(recordingToken),
                           "Recording token hasn't been returned",
                           "Check that recording token has been returned");
                    isCreated  = true;
                    recordings = GetRecordings();
                    Assert(recordings != null,
                           "Recording list is empty",
                           "Check that recording list is not empty");
                    var recording = recordings.FirstOrDefault(r => r.RecordingToken == recordingToken);
                    Assert(recording != null,
                           "Recording is absent",
                           string.Format("Check that recording '{0}' is present in recording list", recordingToken));
                    Assert(recording.Tracks != null && recording.Tracks.Track != null && recording.Tracks.Track.Length > 0,
                           "Track list is empty",
                           string.Format("Check that track list of recording '{0}' is not empty", recordingToken));
                    trackToken = recording.Tracks.Track[0].TrackToken;
                }
                else
                {
                    recordingToken = recordings[0].RecordingToken;
                    trackToken     = recordings[0].Tracks.Track[0].TrackToken;
                }

                this.InvalidTokenTestBody <string>((s, T) => Client.GetTrackConfiguration(T, s), recordingToken,
                                                   RunStep, "Get Track Configuration", null, OnvifFaults.NoTrack);

                this.InvalidTokenTestBody <string>((s, T) => Client.GetTrackConfiguration(s, T), trackToken,
                                                   RunStep, "Get Track Configuration", null, OnvifFaults.NoRecording);
            }, () =>
            {
                if (isCreated)
                {
                    DeleteRecording(recordingToken);
                }
            });
        }