//	using System.Runtime.InteropServices;
//	using System.Linq;
//	using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class EndianStructExtensionTests
{
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct Foo
	{
		public byte b1;
		public short s;
		public ushort S;
		public int i;
		public uint I;
		public long l;
		public ulong L;
		public float f;
		public double d;
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
		public string MyString;
	}

	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct FooReversed
	{
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
		public string MyString;
		public double d;
		public float f;
		public ulong L;
		public long l;
		public uint I;
		public int i;
		public ushort S;
		public short s;
		public byte b1;
	}

	byte[] _defaultBEBytes = new byte[] {
	    1, 
	    0,1,
	    0,1, 
	    0,0,0,1,
	    0,0,0,1, 
	    0,0,0,0,0,0,0,1, 
	    0,0,0,0,0,0,0,1, 
		0x3F,0X80,0,0, // float of 1 (see http://en.wikipedia.org/wiki/Endianness#Floating-point_and_endianness)
		0x3F,0xF0,0,0,0,0,0,0, // double of 1
		0,0,0,0x67,0x6E,0x69,0x74,0x73,0x65,0x54 // Testing\0\0\0
	};

	private FooReversed GetDefaultStruct()
	{
		FooReversed f;
		f.b1 = 1;
		f.s = 1;
		f.S = 1;
		f.i = 1;
		f.I = 1;
		f.l = 1;
		f.L = 1;
		f.f = 1.0f;
		f.d = 1.0;
		f.MyString = "Testing";
		return f;
	}

	[TestMethod]
	public void ToStructHostEndian_BEBytesOfValueOneForMostTypes_Matches()
	{
		byte[] bytes = _defaultBEBytes.Reverse().ToArray();
		FooReversed expected = GetDefaultStruct();

		FooReversed actual = bytes.ToStructureHostEndian<FooReversed>();

		Assert.AreEqual(expected, actual);
	}

	[TestMethod]
	public void ToBytesHostEndian_DefaultStruct_BytesMatch()
	{
		byte[] expected = _defaultBEBytes.Reverse().ToArray();

		byte[] actual = GetDefaultStruct().ToBytesHostEndian();

		CollectionAssert.AreEqual(expected,actual);
	}
}

public static class EndianExtensions 
{	
	/// <summary>
	/// Convert the bytes to a structure in host-endian format (little-endian on PCs).
	/// To use with big-endian data, reverse all of the data bytes and create a struct that is in the reverse order of the data.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="buffer">The buffer.</param>
	/// <returns></returns>
	public static T ToStructureHostEndian<T>(this byte[] buffer) where T : struct
	{
		GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
		T stuff = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
		handle.Free();
		return stuff;
	}
	
	/// <summary>
	/// Converts the struct to a byte array in the endianness of this machine.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	/// <param name="structure">The structure.</param>
	/// <returns></returns>
	public static byte[] ToBytesHostEndian<T>(this T structure) where T : struct
	{
		int size = Marshal.SizeOf(structure);
		var buffer = new byte[size];
		GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
		Marshal.StructureToPtr(structure, handle.AddrOfPinnedObject(), true);
		handle.Free();
		return buffer;
	}
}