private void ToStringContainsMessagesCollection()
{
var errorMessages = new ErrorMessage[] { new ErrorMessage("key1", "message1"), new ErrorMessage("key2", "message2") };
var error = new Error("id", errorMessages);
Assert.Contains("message1", error.ToString());
Assert.Contains("message2", error.ToString());
}
private void HandleError(ISourceLocation errorLocation, Error error, params string[] messageParameters)
// ^ modifies this.scannerAndParserErrors;
//^ ensures this.currentToken == old(this.currentToken);
{
//^ Token oldToken = this.currentToken;
if (this.originalScannerAndParserErrors == this.scannerAndParserErrors) {
}
this.scannerAndParserErrors.Add(new SpecSharpErrorMessage(errorLocation, (long)error, error.ToString(), messageParameters));
//^ assume this.currentToken == oldToken;
}
private void HandleError(Error error, params string[] messageParameters) {
if (this.endPos <= this.lastReportedErrorPos) return;
if (this.scannerErrors == null) return;
this.lastReportedErrorPos = this.endPos;
ISourceLocation errorLocation;
if (error == Error.BadHexDigit)
errorLocation = this.GetSourceLocation(this.endPos - 1, 1);
else
errorLocation = this.GetSourceLocation(this.startPos, this.endPos - this.startPos);
this.scannerErrors.Add(new SpecSharpErrorMessage(errorLocation, (long)error, error.ToString(), messageParameters));
}
/// <summary>
/// This method creates a formatted error message constructed using the format
/// string associated with the given error and the list of supplied arguments.
/// The number of arguments must match that of the format string.
/// </summary>
/// <param name="error">The error for which to return an error message.</param>
/// <param name="args">The arguments (if any) to use in formatting the message.</param>
/// <returns>The formatted error message.</returns>
public static string GetMsg( Error error, params object[] args )
{
lock( msgLock )
{
if( messages.ContainsKey( error.ToString() ) )
{
return FormatMessage( error, args );
}
else
{
return FormatNoMessage( args );
}
}
}
// note: locking not required here since accessed only through public GetMsg method
private static string FormatMessage( Error error, params object[] args )
{
MessageAttribute ma = messages[ error.ToString() ] as MessageAttribute;
if( ma == null || args.Length != ma.ArgumentCount )
{
throw new GentleException( Error.Unspecified,
String.Format( "Unexpected argument count (passed {0}, expected {1}).",
args.Length, ma.ArgumentCount ) );
}
else
{
return Format( ma.Message, args );
}
}
private void OpenMediaCallback(
Error ec)
{
if (ec != Error.success)
{
ErrorOccurred(ec.ToString());
return;
}
Media media;
demuxer_.get_media(out media);
Dictionary<MediaSourceAttributesKeys, string> mediaSourceAttributes =
new Dictionary<MediaSourceAttributesKeys, string>();
mediaSourceAttributes[MediaSourceAttributesKeys.Duration] =
media.duration.ToString();
mediaSourceAttributes[MediaSourceAttributesKeys.CanSeek] =
(media.duration != ulong.MaxValue).ToString();
List<MediaStreamDescription> mediaStreamDescriptions =
new List<MediaStreamDescription>();
for (int i = 0; i < media.streams.Length; ++i)
{
Stream stream = media.streams[i];
Dictionary<MediaStreamAttributeKeys, string> mediaStreamAttributes =
new Dictionary<MediaStreamAttributeKeys, string>();
mediaStreamAttributes[MediaStreamAttributeKeys.CodecPrivateData] =
stream.codec_data.ToString();
if (stream.type == StreamType.video)
{
mediaStreamAttributes[MediaStreamAttributeKeys.VideoFourCC] =
FourCC[(int)stream.sub_type];
mediaStreamAttributes[MediaStreamAttributeKeys.Width] =
stream.video.width.ToString();
mediaStreamAttributes[MediaStreamAttributeKeys.Height] =
stream.video.height.ToString();
char[] CodecPrivateDataHex = new char[stream.codec_data.Length * 2];
int index = 0;
ToHexHelper(CodecPrivateDataHex, ref index, stream.codec_data); // ExtraData
//mediaStreamAttributes[MediaStreamAttributeKeys.CodecPrivateData] =
// new String(CodecPrivateDataHex);
MediaStreamDescription videoStreamDescription =
new MediaStreamDescription(MediaStreamType.Video, mediaStreamAttributes);
mediaStreamDescriptions.Add(videoStreamDescription);
mediaStreamTypes_.Add(MediaStreamType.Video);
mediaStreamDescriptions_[MediaStreamType.Video] = videoStreamDescription;
mediaStreamSamples_[MediaStreamType.Video] = new List<MediaStreamSample>();
//ParseAvcConfig(videoStreamDescription, mediaStreamSamples_[MediaStreamType.Video], stream.codec_data);
}
else if (stream.type == StreamType.audio)
{
char[] WaveFormatExHex = new char[9 * 4 + stream.codec_data.Length * 2];
int index = 0;
ToHexHelper(WaveFormatExHex, ref index, 2, 255); // FormatTag
ToHexHelper(WaveFormatExHex, ref index, 2, stream.audio.channel_count); // Channels
ToHexHelper(WaveFormatExHex, ref index, 4, stream.audio.sample_rate); // SamplesPerSec
ToHexHelper(WaveFormatExHex, ref index, 4, 0); // AverageBytesPerSecond
ToHexHelper(WaveFormatExHex, ref index, 2, 1); // BlockAlign
ToHexHelper(WaveFormatExHex, ref index, 2, stream.audio.sample_size); // BitsPerSample
ToHexHelper(WaveFormatExHex, ref index, 2, stream.codec_data.Length); // ExtraDataSize
ToHexHelper(WaveFormatExHex, ref index, stream.codec_data); // ExtraData
mediaStreamAttributes[MediaStreamAttributeKeys.CodecPrivateData] =
new String(WaveFormatExHex);
MediaStreamDescription audioStreamDescription =
new MediaStreamDescription(MediaStreamType.Audio, mediaStreamAttributes);
mediaStreamDescriptions.Add(audioStreamDescription);
mediaStreamTypes_.Add(MediaStreamType.Audio);
mediaStreamDescriptions_[MediaStreamType.Audio] = audioStreamDescription;
mediaStreamSamples_[MediaStreamType.Audio] = new List<MediaStreamSample>();
}
else
{
mediaStreamTypes_.Add(MediaStreamType.Script);
}
} // for
ReportOpenMediaCompleted(mediaSourceAttributes, mediaStreamDescriptions);
}
private void ToStringContainsId()
{
var error = new Error("12345");
Assert.Contains("12345", error.ToString());
}
/// <summary>
/// Allocates an object providing error information relating to a portion of a source document.
/// </summary>
/// <param name="sourceItem">The source item to which the error applies.</param>
/// <param name="error">An enumeration code that corresponds to this error. The enumeration identifier is used as the message key and the enumeration value is used as the code.</param>
/// <param name="relatedLocations">Zero ore more locations that are related to this error.</param>
/// <param name="messageArguments">Zero or more strings that are to be substituted for "{i}" sequences in the message string return by GetMessage.</param>
public AstErrorMessage(ISourceItem sourceItem, Error error, IEnumerable<ILocation> relatedLocations, params string[] messageArguments)
: base(sourceItem.SourceLocation, (long)error, error.ToString(), relatedLocations, messageArguments) {
}
/// <summary>
/// Allocates an object providing error information relating to a portion of a source document.
/// </summary>
/// <param name="sourceItem">The source item to which the error applies.</param>
/// <param name="error">An enumeration code that corresponds to this error. The enumeration identifier is used as the message key and the enumeration value is used as the code.</param>
/// <param name="messageArguments">Zero or more strings that are to be substituted for "{i}" sequences in the message string return by GetMessage.</param>
public AstErrorMessage(ISourceItem sourceItem, Error error, params string[] messageArguments)
: base(sourceItem.SourceLocation, (long)error, error.ToString(), messageArguments) {
}
private void HandleError(ISourceLocation errorLocation, Error error, params string[] messageParameters)
// ^ modifies this.scannerAndParserErrors;
{
this.scannerAndParserErrors.Add(new SmallBasicErrorMessage(errorLocation, (long)error, error.ToString(), messageParameters));
}
internal static string FormatError(Error code, int pos)
{
return string.Format(SR.ErrorFormat, code.ToString() , pos, (int)code);
}
private void HandleError(Error error, params string[] messageParameters) {
if (this.endPos <= this.lastReportedErrorPos) return;
if (this.scannerErrors == null) return;
this.lastReportedErrorPos = this.endPos;
ISourceLocation errorLocation;
if (error == Error.BadHexDigit) {
//^ assume 0 <= this.offset+this.endPos-1; //no overflow
//^ assume 0 <= this.sourceLocation.StartIndex+this.offset+this.endPos-1; //no overflow
//^ assume this.sourceLocation.StartIndex+this.offset+this.endPos <= this.sourceLocation.Length; //from invariants
errorLocation = this.GetSourceLocation(this.offset+this.endPos-1, 1);
} else {
//^ assume 0 <= this.offset+this.startPos; //no overflow
//^ assume 0 <= this.sourceLocation.StartIndex+this.offset+this.startPos; //no overflow
//^ assume this.sourceLocation.StartIndex+this.offset+this.endPos <= this.sourceLocation.Length; //from invariants
errorLocation = this.GetSourceLocation(this.offset+this.startPos, this.endPos-this.startPos);
}
this.scannerErrors.Add(new SpecSharpErrorMessage(errorLocation, (long)error, error.ToString(), messageParameters));
}
