#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.Specialized;
using System.Web;

namespace Newtonsoft.Utilities.Web
{
public static class UrlUtils
{
public static string GetSchemeHostPort(Uri uri)
{
if (uri == null)
throw new ArgumentNullException(“uri”);

return uri.Scheme + “://” + uri.Host + “:” + uri.Port + “/”;
}

public static string UrlEncodeBase64(string base64Data)
{
return new string(UrlEncodeBase64(base64Data.ToCharArray()));
}

public static char[] UrlEncodeBase64(char[] base64Data)
{
for (int i = 0; i < base64Data.Length; i++) { switch (base64Data[i]) { case '+': base64Data[i] = '@'; break; case '/': base64Data[i] = '$'; break; } } return base64Data; } public static string UrlDecodeBase64(string base64Data) { return new string(UrlDecodeBase64(base64Data.ToCharArray())); } public static char[] UrlDecodeBase64(char[] base64Data) { for (int i = 0; i < base64Data.Length; i++) { switch (base64Data[i]) { case '@': base64Data[i] = '+'; break; case '$': base64Data[i] = '/'; break; } } return base64Data; } } } [/csharp]

//http://www.bouncycastle.org/
//MIT X11 License
using System;
using System.IO;

namespace Org.BouncyCastle.Utilities.Encoders
{
public class Base64Encoder

{
protected readonly byte[] encodingTable =
{
(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
(byte)'v',
(byte)'w', (byte)'x', (byte)'y', (byte)'z',
(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'6',
(byte)'7', (byte)'8', (byte)'9',
(byte)'+', (byte)'/'
};

protected byte padding = (byte)'=';

/*
* set up the decoding table.
*/
protected readonly byte[] decodingTable = new byte[128];

protected void InitialiseDecodingTable()
{
for (int i = 0; i < encodingTable.Length; i++) { decodingTable[encodingTable[i]] = (byte)i; } } public Base64Encoder() { InitialiseDecodingTable(); } /** * encode the input data producing a base 64 output stream. * * @return the number of bytes produced. */ public int Encode( byte[] data, int off, int length, Stream outStream) { int modulus = length % 3; int dataLength = (length - modulus); int a1, a2, a3; for (int i = off; i < off + dataLength; i += 3) { a1 = data[i] & 0xff; a2 = data[i + 1] & 0xff; a3 = data[i + 2] & 0xff; outStream.WriteByte(encodingTable[(int) ((uint) a1 >> 2) & 0x3f]);
outStream.WriteByte(encodingTable[((a1 << 4) | (int) ((uint) a2 >> 4)) & 0x3f]);
outStream.WriteByte(encodingTable[((a2 << 2) | (int) ((uint) a3 >> 6)) & 0x3f]);
outStream.WriteByte(encodingTable[a3 & 0x3f]);
}

/*
* process the tail end.
*/
int b1, b2, b3;
int d1, d2;

switch (modulus)
{
case 0: /* nothing left to do */
break;
case 1:
d1 = data[off + dataLength] & 0xff;
b1 = (d1 >> 2) & 0x3f;
b2 = (d1 << 4) & 0x3f; outStream.WriteByte(encodingTable[b1]); outStream.WriteByte(encodingTable[b2]); outStream.WriteByte(padding); outStream.WriteByte(padding); break; case 2: d1 = data[off + dataLength] & 0xff; d2 = data[off + dataLength + 1] & 0xff; b1 = (d1 >> 2) & 0x3f;
b2 = ((d1 << 4) | (d2 >> 4)) & 0x3f;
b3 = (d2 << 2) & 0x3f; outStream.WriteByte(encodingTable[b1]); outStream.WriteByte(encodingTable[b2]); outStream.WriteByte(encodingTable[b3]); outStream.WriteByte(padding); break; } return (dataLength / 3) * 4 + ((modulus == 0) ? 0 : 4); } private bool ignore( char c) { return (c == ' ' || c ==' ' || c == ' ' || c == ' '); } /** * decode the base 64 encoded byte data writing it to the given output stream, * whitespace characters will be ignored. * * @return the number of bytes produced. */ public int Decode( byte[] data, int off, int length, Stream outStream) { byte b1, b2, b3, b4; int outLen = 0; int end = off + length; while (end > off)
{
if (!ignore((char)data[end – 1]))
{
break;
}

end–;
}

int i = off;
int finish = end – 4;

i = nextI(data, i, finish);

while (i < finish) { b1 = decodingTable[data[i++]]; i = nextI(data, i, finish); b2 = decodingTable[data[i++]]; i = nextI(data, i, finish); b3 = decodingTable[data[i++]]; i = nextI(data, i, finish); b4 = decodingTable[data[i++]]; outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));
outStream.WriteByte((byte)((b2 << 4) | (b3 >> 2)));
outStream.WriteByte((byte)((b3 << 6) | b4)); outLen += 3; i = nextI(data, i, finish); } outLen += decodeLastBlock(outStream, (char)data[end - 4], (char)data[end - 3], (char)data[end - 2], (char)data[end - 1]); return outLen; } private int nextI( byte[] data, int i, int finish) { while ((i < finish) && ignore((char)data[i])) { i++; } return i; } /** * decode the base 64 encoded string data writing it to the given output stream, * whitespace characters will be ignored. * * @return the number of bytes produced. */ public int DecodeString( string data, Stream outStream) { // Platform Implementation // byte[] bytes = Convert.FromBase64String(data); // outStream.Write(bytes, 0, bytes.Length); // return bytes.Length; byte b1, b2, b3, b4; int length = 0; int end = data.Length; while (end > 0)
{
if (!ignore(data[end – 1]))
{
break;
}

end–;
}

int i = 0;
int finish = end – 4;

i = nextI(data, i, finish);

while (i < finish) { b1 = decodingTable[data[i++]]; i = nextI(data, i, finish); b2 = decodingTable[data[i++]]; i = nextI(data, i, finish); b3 = decodingTable[data[i++]]; i = nextI(data, i, finish); b4 = decodingTable[data[i++]]; outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));
outStream.WriteByte((byte)((b2 << 4) | (b3 >> 2)));
outStream.WriteByte((byte)((b3 << 6) | b4)); length += 3; i = nextI(data, i, finish); } length += decodeLastBlock(outStream, data[end - 4], data[end - 3], data[end - 2], data[end - 1]); return length; } private int decodeLastBlock( Stream outStream, char c1, char c2, char c3, char c4) { if (c3 == padding) { byte b1 = decodingTable[c1]; byte b2 = decodingTable[c2]; outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));

return 1;
}

if (c4 == padding)
{
byte b1 = decodingTable[c1];
byte b2 = decodingTable[c2];
byte b3 = decodingTable[c3];

outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));
outStream.WriteByte((byte)((b2 << 4) | (b3 >> 2)));

return 2;
}

{
byte b1 = decodingTable[c1];
byte b2 = decodingTable[c2];
byte b3 = decodingTable[c3];
byte b4 = decodingTable[c4];

outStream.WriteByte((byte)((b1 << 2) | (b2 >> 4)));
outStream.WriteByte((byte)((b2 << 4) | (b3 >> 2)));
outStream.WriteByte((byte)((b3 << 6) | b4)); return 3; } } private int nextI(string data, int i, int finish) { while ((i < finish) && ignore(data[i])) { i++; } return i; } } } [/csharp]

   
 
//http://www.bouncycastle.org/
//MIT X11 License


using System;
using System.IO;
using System.Text;

namespace Org.BouncyCastle.Utilities.Encoders
{
  public sealed class Base64
  {
//    private static readonly IEncoder encoder = new Base64Encoder();

    private Base64()
    {
    }

    /**
     * encode the input data producing a base 64 encoded byte array.
     *
     * @return a byte array containing the base 64 encoded data.
     */
    public static byte[] Encode(
      byte[] data)
    {
      string s = Convert.ToBase64String(data, 0, data.Length);
      return Encoding.ASCII.GetBytes(s);

//      MemoryStream bOut = new MemoryStream();
//      encoder.Encode(data, 0, data.Length, bOut);
//      return bOut.ToArray();
    }

    /**
     * Encode the byte data to base 64 writing it to the given output stream.
     *
     * @return the number of bytes produced.
     */
    public static int Encode(
      byte[]  data,
      Stream  outStream)
    {
      string s = Convert.ToBase64String(data, 0, data.Length);
      byte[] encoded = Encoding.ASCII.GetBytes(s);
      outStream.Write(encoded, 0, encoded.Length);
      return encoded.Length;

//      return encoder.Encode(data, 0, data.Length, outStream);
    }

    /**
     * Encode the byte data to base 64 writing it to the given output stream.
     *
     * @return the number of bytes produced.
     */
    public static int Encode(
      byte[]  data,
      int    off,
      int    length,
      Stream  outStream)
    {
      string s = Convert.ToBase64String(data, off, length);
      byte[] encoded = Encoding.ASCII.GetBytes(s);
      outStream.Write(encoded, 0, encoded.Length);
      return encoded.Length;

//      return encoder.Encode(data, off, length, outStream);
    }

    /**
     * decode the base 64 encoded input data. It is assumed the input data is valid.
     *
     * @return a byte array representing the decoded data.
     */
    public static byte[] Decode(
      byte[] data)
    {
      string s = Encoding.ASCII.GetString(data, 0, data.Length);
      return Convert.FromBase64String(s);

//      MemoryStream bOut = new MemoryStream();
//      encoder.Decode(data, 0, data.Length, bOut);
//      return bOut.ToArray();
    }

    /**
     * decode the base 64 encoded string data - whitespace will be ignored.
     *
     * @return a byte array representing the decoded data.
     */
    public static byte[] Decode(
      string data)
    {
      return Convert.FromBase64String(data);

//      MemoryStream bOut = new MemoryStream();
//      encoder.DecodeString(data, bOut);
//      return bOut.ToArray();
    }

    /**
     * decode the base 64 encoded string data writing it to the given output stream,
     * whitespace characters will be ignored.
     *
     * @return the number of bytes produced.
     */
    public static int Decode(
      string  data,
      Stream  outStream)
    {
      byte[] decoded = Decode(data);
      outStream.Write(decoded, 0, decoded.Length);
      return decoded.Length;

//      return encoder.DecodeString(data, outStream);
    }
  }
}

   
     

   
 
// Portions copyright 2005 - 2007: Diego Guidi
// Portions copyright 2006 - 2008: Rory Plaire (codekaizen@gmail.com)
//
// This file is part of GeoAPI.
// GeoAPI is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// GeoAPI is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License
// along with GeoAPI; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 

#if NETCF
using System;

namespace GeoAPI.DataStructures
{
    /// <summary>
    /// A supoort class: the purpose is to integrate System.BitConverter 
    /// methods not presents in .NET Compact Framework.
    /// </summary>
    public class BitConverter
    {
        public static Int64 DoubleToInt64Bits(Double x)
        {
#if UNSAFE
            unsafe
            {
                return *(Int64*)&amp;x;
            }
#else
            Byte[] bytes = System.BitConverter.GetBytes(x);
            Int64 value = System.BitConverter.ToInt64(bytes, 0);
            return value;
#endif
        }

        public static Double Int64BitsToDouble(Int64 x)
        {
#if UNSAFE
            unsafe
            {
                return *(Double*)&amp;x;
            }
#else
            Byte[] bytes = System.BitConverter.GetBytes(x);
            Double value = System.BitConverter.ToDouble(bytes, 0);
            return value;
#endif
        }
    }
}
#endif

   
     

   
 


using System;
using System.Diagnostics;
   
public class TestClass
{
    public void Method1()
    {
        Console.WriteLine("Hello from Method1!");
    }
   
    [Conditional("DEBUG")]
    public void Method2()
    {
        Console.WriteLine("Hello from Method2!");
    }
   
    public void Method3()
    {
        Console.WriteLine("Hello from Method3!");
    }
   
}
   
class MainClass
{
    public static void Main()
    {
        TestClass MyTestClass = new TestClass();
   
        MyTestClass.Method1();
        MyTestClass.Method2();
        MyTestClass.Method3();
    }
}

    

   


// compile with: csc /r:system.dll file_1.cs

using System;
using System.Diagnostics;

class MyClass
{
    public MyClass(int i)
    {
        this.i = i;
    }
    
    [Conditional("DEBUG")]
    public void VerifyState()
    {
        Debug.Assert(i == 0, "Bad State");
    }
    
    int i = 0;
}

public class DefensiveProgrammingAsserts
{
    public static void Main()
    {
        Debug.Listeners.Clear();
        Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
        MyClass c = new MyClass(1);
        
        c.VerifyState();
    }
}
           
          

   

using System;
using System.Collections;
using System.Diagnostics;

class Class1 {
   static void Main(string[] args) {
     Debug.Fail("Fail Message", "An unexpected exception has been thrown.

");
   }
}