// Authors:
// Duncan Mak <duncan@ximian.com>
// Dick Porter <dick@ximian.com>
+// Gert Driesen <drieseng@users.sourceforge.net>
//
// (C) 2001, 2002 Ximian, Inc. http://www.ximian.com
//
}
#if NET_2_0
- SortedList resources = new SortedList (StringComparer.Ordinal);
+ SortedList resources = new SortedList (StringComparer.OrdinalIgnoreCase);
#else
- Hashtable resources = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
+ Hashtable resources = new Hashtable (CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
#endif
Stream stream;
public ResourceWriter (Stream stream)
{
if (stream == null)
- throw new ArgumentNullException ("stream is null");
- if (stream.CanWrite == false)
- throw new ArgumentException ("stream is not writable.");
+ throw new ArgumentNullException ("stream");
+ if (!stream.CanWrite)
+ throw new ArgumentException ("Stream was not writable.");
- this.stream=stream;
+ this.stream = stream;
}
public ResourceWriter (String fileName)
{
if (fileName == null)
- throw new ArgumentNullException ("fileName is null.");
+ throw new ArgumentNullException ("fileName");
- stream=new FileStream(fileName, FileMode.Create, FileAccess.Write);
+ stream = new FileStream(fileName, FileMode.Create,
+ FileAccess.Write);
}
public void AddResource (string name, byte[] value)
{
- if (name == null) {
- throw new ArgumentNullException ("name is null");
- }
- if (value == null) {
- throw new ArgumentNullException ("value is null");
- }
- if(resources==null) {
- throw new InvalidOperationException ("ResourceWriter has been closed");
- }
- if(resources[name]!=null) {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ if (resources == null)
+ throw new InvalidOperationException ("The resource writer has already been closed and cannot be edited");
+ if (resources [name] != null)
throw new ArgumentException ("Resource already present: " + name);
- }
resources.Add(name, value);
}
public void AddResource (string name, object value)
- {
- if (name == null) {
- throw new ArgumentNullException ("name is null");
- }
- if(resources==null) {
- throw new InvalidOperationException ("ResourceWriter has been closed");
- }
- if(resources[name]!=null) {
+ {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ if (resources == null)
+ throw new InvalidOperationException ("The resource writer has already been closed and cannot be edited");
+ if (resources[name] != null)
throw new ArgumentException ("Resource already present: " + name);
- }
resources.Add(name, value);
}
public void AddResource (string name, string value)
{
- if (name == null) {
- throw new ArgumentNullException ("name is null");
- }
- if (value == null) {
- throw new ArgumentNullException ("value is null");
- }
- if(resources==null) {
- throw new InvalidOperationException ("ResourceWriter has been closed");
- }
- if(resources[name]!=null) {
+ if (name == null)
+ throw new ArgumentNullException ("name");
+ if (resources == null)
+ throw new InvalidOperationException ("The resource writer has already been closed and cannot be edited");
+ if (resources [name] != null)
throw new ArgumentException ("Resource already present: " + name);
- }
resources.Add(name, value);
}
- public void Close () {
- Dispose(true);
+ public void Close ()
+ {
+ Dispose (true);
}
public void Dispose ()
{
- Dispose(true);
+ Dispose (true);
}
private void Dispose (bool disposing)
{
- if(disposing) {
- if(resources.Count>0 && generated==false) {
+ if (disposing) {
+ if (resources != null)
Generate();
- }
- if(stream!=null) {
+ if (stream != null)
stream.Close();
- }
- // If we are explicitly disposed, we can avoid finalization.
GC.SuppressFinalize (this);
}
- resources=null;
- stream=null;
+ resources = null;
+ stream = null;
}
#if NET_2_0
}
#endif
- private bool generated=false;
-
- public void Generate () {
+ public void Generate ()
+ {
BinaryWriter writer;
IFormatter formatter;
- if(resources==null) {
- throw new InvalidOperationException ("ResourceWriter has been closed");
- }
+ if (resources == null)
+ throw new InvalidOperationException ("The resource writer has already been closed and cannot be edited");
- if(generated) {
- throw new InvalidOperationException ("ResourceWriter can only Generate() once");
- }
- generated=true;
-
- writer=new BinaryWriter(stream, Encoding.UTF8);
- formatter=new BinaryFormatter(null, new StreamingContext(StreamingContextStates.File|StreamingContextStates.Persistence));
+ writer = new BinaryWriter (stream, Encoding.UTF8);
+ formatter = new BinaryFormatter (null, new StreamingContext (StreamingContextStates.File | StreamingContextStates.Persistence));
/* The ResourceManager header */
- writer.Write(ResourceManager.MagicNumber);
- writer.Write(ResourceManager.HeaderVersionNumber);
+ writer.Write (ResourceManager.MagicNumber);
+ writer.Write (ResourceManager.HeaderVersionNumber);
/* Build the rest of the ResourceManager
* header in memory, because we need to know
* how long it is in advance
*/
- MemoryStream resman_stream=new MemoryStream();
- BinaryWriter resman=new BinaryWriter(resman_stream,
+ MemoryStream resman_stream = new MemoryStream ();
+ BinaryWriter resman = new BinaryWriter (resman_stream,
Encoding.UTF8);
- resman.Write(typeof(ResourceReader).AssemblyQualifiedName);
+ resman.Write (typeof (ResourceReader).AssemblyQualifiedName);
#if NET_2_0
- resman.Write(typeof(ResourceSet).FullName);
+ resman.Write (typeof (ResourceSet).FullName);
#else
- resman.Write(typeof(ResourceSet).AssemblyQualifiedName);
+ resman.Write (typeof (ResourceSet).AssemblyQualifiedName);
#endif
/* Only space for 32 bits of header len in the
* resource file format
*/
- int resman_len=(int)resman_stream.Length;
- writer.Write(resman_len);
- writer.Write(resman_stream.GetBuffer(), 0, resman_len);
+ int resman_len = (int) resman_stream.Length;
+ writer.Write (resman_len);
+ writer.Write (resman_stream.GetBuffer (), 0, resman_len);
/* We need to build the ResourceReader name
* and data sections simultaneously
*/
- MemoryStream res_name_stream=new MemoryStream();
- BinaryWriter res_name=new BinaryWriter(res_name_stream, Encoding.Unicode);
+ MemoryStream res_name_stream = new MemoryStream ();
+ BinaryWriter res_name = new BinaryWriter (res_name_stream, Encoding.Unicode);
- MemoryStream res_data_stream=new MemoryStream();
- BinaryWriter res_data=new BinaryWriter(res_data_stream,
+ MemoryStream res_data_stream = new MemoryStream ();
+ BinaryWriter res_data = new BinaryWriter (res_data_stream,
Encoding.UTF8);
/* Not sure if this is the best collection to
* key==value would work, but I need to find
* the index of each item later)
*/
- ArrayList types=new ArrayList();
- int[] hashes=new int[resources.Count];
- int[] name_offsets=new int[resources.Count];
- int count=0;
+ ArrayList types = new ArrayList ();
+ int [] hashes = new int [resources.Count];
+ int [] name_offsets = new int [resources.Count];
+ int count = 0;
- IDictionaryEnumerator res_enum=resources.GetEnumerator();
- while(res_enum.MoveNext()) {
+ IDictionaryEnumerator res_enum = resources.GetEnumerator ();
+ while (res_enum.MoveNext()) {
/* Hash the name */
- hashes[count]=GetHash((string)res_enum.Key);
+ hashes [count] = GetHash ((string) res_enum.Key);
/* Record the offsets */
- name_offsets[count]=(int)res_name.BaseStream.Position;
+ name_offsets [count] = (int) res_name.BaseStream.Position;
/* Write the name section */
- res_name.Write((string)res_enum.Key);
- res_name.Write((int)res_data.BaseStream.Position);
+ res_name.Write ((string) res_enum.Key);
+ res_name.Write ((int) res_data.BaseStream.Position);
if (res_enum.Value == null) {
Write7BitEncodedInt (res_data, -1);
#if NET_2_0
if (tbn != null)
res_data.Write((byte []) tbn.Value);
- else if (type==typeof(Byte)) {
- res_data.Write((byte) PredefinedResourceType.Byte);
- res_data.Write((Byte)res_enum.Value);
- } else if (type==typeof(Decimal)) {
- res_data.Write((byte) PredefinedResourceType.Decimal);
- res_data.Write((Decimal)res_enum.Value);
- } else if (type==typeof(DateTime)) {
- res_data.Write((byte) PredefinedResourceType.DateTime);
- res_data.Write(((DateTime)res_enum.Value).Ticks);
- } else if (type==typeof(Double)) {
- res_data.Write((byte) PredefinedResourceType.Double);
- res_data.Write((Double)res_enum.Value);
- } else if (type==typeof(Int16)) {
- res_data.Write((byte) PredefinedResourceType.Int16);
- res_data.Write((Int16)res_enum.Value);
- } else if (type==typeof(Int32)) {
- res_data.Write((byte) PredefinedResourceType.Int32);
- res_data.Write((Int32)res_enum.Value);
- } else if (type==typeof(Int64)) {
- res_data.Write((byte) PredefinedResourceType.Int64);
- res_data.Write((Int64)res_enum.Value);
- } else if (type==typeof(SByte)) {
- res_data.Write((byte) PredefinedResourceType.SByte);
- res_data.Write((SByte)res_enum.Value);
- } else if (type==typeof(Single)) {
- res_data.Write((byte) PredefinedResourceType.Single);
- res_data.Write((Single)res_enum.Value);
- } else if (type==typeof(String)) {
- res_data.Write((byte) PredefinedResourceType.String);
- res_data.Write((String)res_enum.Value);
- } else if (type==typeof(TimeSpan)) {
- res_data.Write((byte) PredefinedResourceType.TimeSpan);
- res_data.Write(((TimeSpan)res_enum.Value).Ticks);
- } else if (type==typeof(UInt16)) {
- res_data.Write((byte) PredefinedResourceType.UInt16);
- res_data.Write((UInt16)res_enum.Value);
- } else if (type==typeof(UInt32)) {
- res_data.Write((byte) PredefinedResourceType.UInt32);
- res_data.Write((UInt32)res_enum.Value);
- } else if (type==typeof(UInt64)) {
- res_data.Write((byte) PredefinedResourceType.UInt64);
- res_data.Write((UInt64)res_enum.Value);
- } else if (type==typeof(byte[])) {
- res_data.Write((byte) PredefinedResourceType.ByteArray);
- byte [] data = (byte[])res_enum.Value;
- res_data.Write((uint) data.Length);
- res_data.Write(data, 0, data.Length);
- } else if (type==typeof(MemoryStream)) {
- res_data.Write((byte) PredefinedResourceType.Stream);
- byte [] data = ((MemoryStream)res_enum.Value).ToArray ();
- res_data.Write((uint) data.Length);
- res_data.Write(data, 0, data.Length);
+ else if (type == typeof (Byte)) {
+ res_data.Write ((byte) PredefinedResourceType.Byte);
+ res_data.Write ((Byte) res_enum.Value);
+ } else if (type == typeof (Decimal)) {
+ res_data.Write ((byte) PredefinedResourceType.Decimal);
+ res_data.Write ((Decimal) res_enum.Value);
+ } else if (type == typeof (DateTime)) {
+ res_data.Write ((byte) PredefinedResourceType.DateTime);
+ res_data.Write (((DateTime) res_enum.Value).Ticks);
+ } else if (type == typeof (Double)) {
+ res_data.Write ((byte) PredefinedResourceType.Double);
+ res_data.Write ((Double) res_enum.Value);
+ } else if (type == typeof (Int16)) {
+ res_data.Write ((byte) PredefinedResourceType.Int16);
+ res_data.Write ((Int16) res_enum.Value);
+ } else if (type == typeof (Int32)) {
+ res_data.Write ((byte) PredefinedResourceType.Int32);
+ res_data.Write ((Int32) res_enum.Value);
+ } else if (type == typeof (Int64)) {
+ res_data.Write ((byte) PredefinedResourceType.Int64);
+ res_data.Write ((Int64) res_enum.Value);
+ } else if (type == typeof (SByte)) {
+ res_data.Write ((byte) PredefinedResourceType.SByte);
+ res_data.Write ((SByte) res_enum.Value);
+ } else if (type == typeof (Single)) {
+ res_data.Write ((byte) PredefinedResourceType.Single);
+ res_data.Write ((Single) res_enum.Value);
+ } else if (type == typeof (String)) {
+ res_data.Write ((byte) PredefinedResourceType.String);
+ res_data.Write ((String) res_enum.Value);
+ } else if (type == typeof (TimeSpan)) {
+ res_data.Write ((byte) PredefinedResourceType.TimeSpan);
+ res_data.Write (((TimeSpan) res_enum.Value).Ticks);
+ } else if (type == typeof (UInt16)) {
+ res_data.Write ((byte) PredefinedResourceType.UInt16);
+ res_data.Write ((UInt16) res_enum.Value);
+ } else if (type == typeof (UInt32)) {
+ res_data.Write ((byte) PredefinedResourceType.UInt32);
+ res_data.Write ((UInt32) res_enum.Value);
+ } else if (type == typeof (UInt64)) {
+ res_data.Write ((byte) PredefinedResourceType.UInt64);
+ res_data.Write ((UInt64) res_enum.Value);
+ } else if (type == typeof (byte[])) {
+ res_data.Write ((byte) PredefinedResourceType.ByteArray);
+ byte [] data = (byte[]) res_enum.Value;
+ res_data.Write ((uint) data.Length);
+ res_data.Write (data, 0, data.Length);
+ } else if (type == typeof (MemoryStream)) {
+ res_data.Write ((byte) PredefinedResourceType.Stream);
+ byte [] data = ((MemoryStream) res_enum.Value).ToArray ();
+ res_data.Write ((uint) data.Length);
+ res_data.Write (data, 0, data.Length);
} else {
/* non-intrinsic types are
* serialized
*/
- formatter.Serialize(res_data.BaseStream, res_enum.Value);
+ formatter.Serialize (res_data.BaseStream, res_enum.Value);
}
#else
- if(type==typeof(Byte)) {
- res_data.Write((Byte)res_enum.Value);
- } else if (type==typeof(Decimal)) {
- res_data.Write((Decimal)res_enum.Value);
- } else if (type==typeof(DateTime)) {
- res_data.Write(((DateTime)res_enum.Value).Ticks);
- } else if (type==typeof(Double)) {
- res_data.Write((Double)res_enum.Value);
- } else if (type==typeof(Int16)) {
- res_data.Write((Int16)res_enum.Value);
- } else if (type==typeof(Int32)) {
- res_data.Write((Int32)res_enum.Value);
- } else if (type==typeof(Int64)) {
- res_data.Write((Int64)res_enum.Value);
- } else if (type==typeof(SByte)) {
- res_data.Write((SByte)res_enum.Value);
- } else if (type==typeof(Single)) {
- res_data.Write((Single)res_enum.Value);
- } else if (type==typeof(String)) {
- res_data.Write((String)res_enum.Value);
- } else if (type==typeof(TimeSpan)) {
- res_data.Write(((TimeSpan)res_enum.Value).Ticks);
- } else if (type==typeof(UInt16)) {
- res_data.Write((UInt16)res_enum.Value);
- } else if (type==typeof(UInt32)) {
- res_data.Write((UInt32)res_enum.Value);
- } else if (type==typeof(UInt64)) {
- res_data.Write((UInt64)res_enum.Value);
+ if (type == typeof (Byte)) {
+ res_data.Write ((Byte) res_enum.Value);
+ } else if (type == typeof (Decimal)) {
+ res_data.Write ((Decimal) res_enum.Value);
+ } else if (type == typeof (DateTime)) {
+ res_data.Write (((DateTime) res_enum.Value).Ticks);
+ } else if (type == typeof (Double)) {
+ res_data.Write ((Double) res_enum.Value);
+ } else if (type == typeof (Int16)) {
+ res_data.Write ((Int16) res_enum.Value);
+ } else if (type == typeof (Int32)) {
+ res_data.Write ((Int32) res_enum.Value);
+ } else if (type == typeof (Int64)) {
+ res_data.Write ((Int64) res_enum.Value);
+ } else if (type == typeof (SByte)) {
+ res_data.Write ((SByte) res_enum.Value);
+ } else if (type == typeof (Single)) {
+ res_data.Write ((Single) res_enum.Value);
+ } else if (type == typeof (String)) {
+ res_data.Write ((String) res_enum.Value);
+ } else if (type == typeof (TimeSpan)) {
+ res_data.Write (((TimeSpan) res_enum.Value).Ticks);
+ } else if (type == typeof (UInt16)) {
+ res_data.Write ((UInt16) res_enum.Value);
+ } else if (type == typeof (UInt32)) {
+ res_data.Write ((UInt32) res_enum.Value);
+ } else if (type == typeof (UInt64)) {
+ res_data.Write ((UInt64) res_enum.Value);
} else {
/* non-intrinsic types are
* serialized
*/
- formatter.Serialize(res_data.BaseStream, res_enum.Value);
+ formatter.Serialize (res_data.BaseStream, res_enum.Value);
}
#endif
/* Sort the hashes, keep the name offsets
* matching up
*/
- Array.Sort(hashes, name_offsets);
+ Array.Sort (hashes, name_offsets);
/* now do the ResourceReader header */
#if NET_2_0
- writer.Write(2);
+ writer.Write (2);
#else
- writer.Write(1);
+ writer.Write (1);
#endif
- writer.Write(resources.Count);
- writer.Write(types.Count);
+ writer.Write (resources.Count);
+ writer.Write (types.Count);
/* Write all of the unique types */
- foreach(object type in types) {
+ foreach (object type in types) {
if (type is Type)
writer.Write(((Type) type).AssemblyQualifiedName);
else
/* Pad the next fields (hash values) on an 8
* byte boundary, using the letters "PAD"
*/
- int pad_align=(int)(writer.BaseStream.Position & 7);
- int pad_chars=0;
+ int pad_align = (int) (writer.BaseStream.Position & 7);
+ int pad_chars = 0;
- if(pad_align!=0) {
- pad_chars=8-pad_align;
- }
+ if (pad_align != 0)
+ pad_chars = 8 - pad_align;
- for(int i=0; i<pad_chars; i++) {
- writer.Write((byte)"PAD"[i%3]);
- }
+ for (int i = 0; i < pad_chars; i++)
+ writer.Write ((byte) "PAD" [i % 3]);
/* Write the hashes */
- for(int i=0; i<resources.Count; i++) {
- writer.Write(hashes[i]);
- }
+ for (int i = 0; i < resources.Count; i++)
+ writer.Write (hashes[i]);
/* and the name offsets */
- for(int i=0; i<resources.Count; i++) {
- writer.Write(name_offsets[i]);
- }
+ for (int i = 0; i < resources.Count; i++)
+ writer.Write (name_offsets [i]);
/* Write the data section offset */
- int data_offset=(int)writer.BaseStream.Position +
- (int)res_name_stream.Length + 4;
- writer.Write(data_offset);
+ int data_offset= (int) writer.BaseStream.Position +
+ (int) res_name_stream.Length + 4;
+ writer.Write (data_offset);
/* The name section goes next */
- writer.Write(res_name_stream.GetBuffer(), 0,
- (int)res_name_stream.Length);
+ writer.Write (res_name_stream.GetBuffer(), 0,
+ (int) res_name_stream.Length);
/* The data section is last */
- writer.Write(res_data_stream.GetBuffer(), 0,
- (int)res_data_stream.Length);
+ writer.Write (res_data_stream.GetBuffer(), 0,
+ (int) res_data_stream.Length);
- res_name.Close();
- res_data.Close();
+ res_name.Close ();
+ res_data.Close ();
/* Don't close writer, according to the spec */
- writer.Flush();
+ writer.Flush ();
+
+ // ResourceWriter is no longer editable
+ resources = null;
}
// looks like it is (similar to) DJB hash
- private int GetHash(string name)
+ int GetHash (string name)
{
- uint hash=5381;
+ uint hash = 5381;
- for(int i=0; i<name.Length; i++) {
- hash=((hash<<5)+hash)^name[i];
- }
+ for (int i=0; i<name.Length; i++)
+ hash = ((hash << 5) + hash) ^ name [i];
- return((int)hash);
+ return ((int) hash);
}
/* Cut and pasted from BinaryWriter, because it's
* 'protected' there.
*/
- private void Write7BitEncodedInt(BinaryWriter writer,
- int value)
+ void Write7BitEncodedInt (BinaryWriter writer, int value)
{
do {
int high = (value >> 7) & 0x01ffffff;
- byte b = (byte)(value & 0x7f);
+ byte b = (byte) (value & 0x7f);
- if (high != 0) {
- b = (byte)(b | 0x80);
- }
+ if (high != 0)
+ b = (byte) (b | 0x80);
- writer.Write(b);
+ writer.Write (b);
value = high;
- } while(value != 0);
+ } while (value != 0);
}
internal Stream Stream {
[TestFixture]
public class ResourceWriterTest
{
+ private string tempFolder = null;
+
+ [SetUp]
+ public void SetUp ()
+ {
+ tempFolder = Path.Combine (Path.GetTempPath (),
+ "MonoTests.System.Resources.ResourceWriterTest");
+ if (!Directory.Exists (tempFolder))
+ Directory.CreateDirectory (tempFolder);
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ if (Directory.Exists (tempFolder))
+ Directory.Delete (tempFolder, true);
+ }
+
+ [Test] // ctor (Stream)
+ public void Constructor0_Stream_NotWritable ()
+ {
+ MemoryStream ms = new MemoryStream (new byte [0], false);
+
+ try {
+ new ResourceWriter (ms);
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // Stream was not writable
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // ctor (Stream)
+ public void Constructor0_Stream_Null ()
+ {
+ try {
+ new ResourceWriter ((Stream) null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNotNull (ex.ParamName, "#5");
+ Assert.AreEqual ("stream", ex.ParamName, "#6");
+ }
+ }
+
+ [Test] // ctor (string)
+ public void Constructor1_FileName_Null ()
+ {
+ try {
+ new ResourceWriter ((string) null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNotNull (ex.ParamName, "#5");
+ Assert.AreEqual ("fileName", ex.ParamName, "#6");
+ }
+ }
+
+ [Test] // AddResource (string, byte [])
+ public void AddResource0 ()
+ {
+ byte [] value = new byte [] { 5, 7 };
+
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", value);
+ writer.Generate ();
+
+ try {
+ writer.AddResource ("Address", new byte [] { 8, 12 });
+ Assert.Fail ("#A1");
+ } catch (InvalidOperationException ex) {
+ // The resource writer has already been closed
+ // and cannot be edited
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ }
+
+ ms.Position = 0;
+ ResourceReader rr = new ResourceReader (ms);
+ IDictionaryEnumerator enumerator = rr.GetEnumerator ();
+ Assert.IsTrue (enumerator.MoveNext (), "#B1");
+ Assert.AreEqual ("Name", enumerator.Key, "#B3");
+ Assert.AreEqual (value, enumerator.Value, "#B4");
+ Assert.IsFalse (enumerator.MoveNext (), "#B5");
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, byte [])
+ public void AddResource0_Name_Null ()
+ {
+ byte [] value = new byte [] { 5, 7 };
+
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+
+ try {
+ writer.AddResource ((string) null, value);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNotNull (ex.ParamName, "#5");
+ Assert.AreEqual ("name", ex.ParamName, "#6");
+ }
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, byte [])
+ public void AddResource0_Value_Null ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", (byte []) null);
+ writer.Generate ();
+
+ ms.Position = 0;
+ ResourceReader rr = new ResourceReader (ms);
+ IDictionaryEnumerator enumerator = rr.GetEnumerator ();
+ Assert.IsTrue (enumerator.MoveNext (), "#1");
+ Assert.AreEqual ("Name", enumerator.Key, "#2");
+ Assert.IsNull (enumerator.Value, "#3");
+ Assert.IsFalse (enumerator.MoveNext (), "#4");
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, object)
+ public void AddResource1 ()
+ {
+ TimeSpan value = new TimeSpan (2, 5, 8);
+
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Interval", value);
+ writer.Generate ();
+
+ try {
+ writer.AddResource ("Start", value);
+ Assert.Fail ("#A1");
+ } catch (InvalidOperationException ex) {
+ // The resource writer has already been closed
+ // and cannot be edited
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ }
+
+ ms.Position = 0;
+ ResourceReader rr = new ResourceReader (ms);
+ IDictionaryEnumerator enumerator = rr.GetEnumerator ();
+ Assert.IsTrue (enumerator.MoveNext (), "#B1");
+ Assert.AreEqual ("Interval", enumerator.Key, "#B3");
+ Assert.AreEqual (value, enumerator.Value, "#B4");
+ Assert.IsFalse (enumerator.MoveNext (), "#B5");
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, object)
+ public void AddResource1_Name_Null ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+
+ try {
+ writer.AddResource ((string) null, new object ());
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNotNull (ex.ParamName, "#5");
+ Assert.AreEqual ("name", ex.ParamName, "#6");
+ }
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, object)
+ public void AddResource1_Value_Null ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", (object) null);
+ writer.Generate ();
+
+ ms.Position = 0;
+ ResourceReader rr = new ResourceReader (ms);
+ IDictionaryEnumerator enumerator = rr.GetEnumerator ();
+ Assert.IsTrue (enumerator.MoveNext (), "#1");
+ Assert.AreEqual ("Name", enumerator.Key, "#2");
+ Assert.IsNull (enumerator.Value, "#3");
+ Assert.IsFalse (enumerator.MoveNext (), "#4");
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, string)
+ public void AddResource2 ()
+ {
+ String value = "Some\0Value\tOr\rAnother";
+
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Text", value);
+ writer.Generate ();
+
+ try {
+ writer.AddResource ("Description", value);
+ Assert.Fail ("#A1");
+ } catch (InvalidOperationException ex) {
+ // The resource writer has already been closed
+ // and cannot be edited
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ }
+
+ ms.Position = 0;
+ ResourceReader rr = new ResourceReader (ms);
+ IDictionaryEnumerator enumerator = rr.GetEnumerator ();
+ Assert.IsTrue (enumerator.MoveNext (), "#B1");
+ Assert.AreEqual ("Text", enumerator.Key, "#B3");
+ Assert.AreEqual (value, enumerator.Value, "#B4");
+ Assert.IsFalse (enumerator.MoveNext (), "#B5");
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, string)
+ public void AddResource2_Name_Null ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+
+ try {
+ writer.AddResource ((string) null, "abc");
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNotNull (ex.ParamName, "#5");
+ Assert.AreEqual ("name", ex.ParamName, "#6");
+ }
+
+ writer.Close ();
+ }
+
+ [Test] // AddResource (string, string)
+ public void AddResource2_Value_Null ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", (string) null);
+ writer.Generate ();
+
+ ms.Position = 0;
+ ResourceReader rr = new ResourceReader (ms);
+ IDictionaryEnumerator enumerator = rr.GetEnumerator ();
+ Assert.IsTrue (enumerator.MoveNext (), "#1");
+ Assert.AreEqual ("Name", enumerator.Key, "#2");
+ Assert.IsNull (enumerator.Value, "#3");
+ Assert.IsFalse (enumerator.MoveNext (), "#4");
+
+ writer.Close ();
+ }
+
+ [Test]
+ public void AddResource_Closed ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", "Miguel");
+ writer.Close ();
+
+ try {
+ writer.AddResource ("Address", "US");
+ Assert.Fail ("#1");
+ } catch (InvalidOperationException ex) {
+ // The resource writer has already been closed
+ // and cannot be edited
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ }
+ }
+
+ [Test]
+ public void AddResource_Name_Duplicate ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("FirstName", "Miguel");
+
+ try {
+ writer.AddResource ("FirstNaMe", "Chris");
+ Assert.Fail ("#1");
+ } catch (ArgumentException ex) {
+ // Item has already been added. Key is dictionary:
+ // 'FirstName' Key being added: 'FirstNaMe'
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+ }
+
+ writer.AddResource ("Name", "Miguel");
+ writer.Close ();
+ }
+
#if NET_2_0
[Test]
public void Bug81759 ()
}
#endif
+ [Test]
+ public void Close ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", "Miguel");
+ Assert.IsTrue (ms.CanWrite, "#A1");
+ Assert.IsTrue (ms.GetBuffer ().Length == 0, "#A2");
+ writer.Close ();
+ Assert.IsFalse (ms.CanWrite, "#B1");
+ Assert.IsFalse (ms.GetBuffer ().Length == 0, "#B2");
+ writer.Close ();
+ }\r
+\r
+ [Test] // bug #339074
+ public void Close_NoResources ()
+ {
+ string tempFile = Path.Combine (AppDomain.CurrentDomain.BaseDirectory,
+ "test.resources");
+
+ ResourceWriter writer = new ResourceWriter (tempFile);
+ writer.Close ();
+
+ using (FileStream fs = File.OpenRead (tempFile)) {
+ Assert.IsFalse (fs.Length == 0, "#1");
+
+ using (ResourceReader reader = new ResourceReader (fs)) {
+ Assert.IsFalse (reader.GetEnumerator ().MoveNext (), "#2");
+ }
+ }
+ }
+
+ [Test]
+ public void Generate ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", "Miguel");
+ Assert.IsTrue (ms.Length == 0, "#A1");
+ Assert.IsTrue (ms.CanWrite, "#A2");
+ writer.Generate ();
+ Assert.IsFalse (ms.Length == 0, "#B2");
+ Assert.IsTrue (ms.CanWrite, "#B2");
+
+ try {
+ writer.Generate ();
+ Assert.Fail ("#C1");
+ } catch (InvalidOperationException ex) {
+ // The resource writer has already been closed
+ // and cannot be edited
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
+ Assert.IsNull (ex.InnerException, "#C3");
+ Assert.IsNotNull (ex.Message, "#C4");
+ }
+
+ writer.Close ();
+ }
+
+ [Test]
+ public void Generate_Closed ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ ResourceWriter writer = new ResourceWriter (ms);
+ writer.AddResource ("Name", "Miguel");
+ writer.Close ();
+
+ try {
+ writer.Generate ();
+ Assert.Fail ("#B1");
+ } catch (InvalidOperationException ex) {
+ // The resource writer has already been closed
+ // and cannot be edited
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ }
+ }
+
[Test] // bug #82566
#if NET_2_0
[Category ("NotWorking")]
projects / mono.git / commitdiff