mcs/class/System.Net.Http/Test/System.Net.Http.Headers/RangeHeaderValueTest.cs

   1 //
   2 // RangeHeaderValueTest.cs
   3 //
   4 // Authors:
   5 //      Marek Safar  <marek.safar@gmail.com>
   6 //
   7 // Copyright (C) 2011 Xamarin Inc (http://www.xamarin.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.Collections;
  31 using System.Collections.Generic;
  32 using NUnit.Framework;
  33 using System.Net.Http.Headers;
  34 using System.Linq;
  35
  36 namespace MonoTests.System.Net.Http.Headers
  37 {
  38         [TestFixture]
  39         public class RangeHeaderValueTest
  40         {
  41                 [Test]
  42                 public void Ctor_InvalidArguments ()
  43                 {
  44                         try {
  45                                 new RangeHeaderValue (null, null);
  46                                 Assert.Fail ("#1");
  47                         } catch (ArgumentException) {
  48                         }
  49
  50                         try {
  51                                 new RangeHeaderValue (long.MinValue, null);
  52                                 Assert.Fail ("#2");
  53                         } catch (ArgumentOutOfRangeException) {
  54                         }
  55
  56                         try {
  57                                 new RangeHeaderValue (10, 1);
  58                                 Assert.Fail ("#3");
  59                         } catch (ArgumentOutOfRangeException) {
  60                         }
  61                 }
  62
  63                 [Test]
  64                 public void Equals ()
  65                 {
  66                         var value = new RangeHeaderValue (4, null);
  67                         Assert.AreEqual (value, new RangeHeaderValue (4, null), "#1");
  68                         Assert.AreNotEqual (value, new RangeHeaderValue (4, 5), "#2");
  69                         Assert.AreNotEqual (value, new RangeHeaderValue (), "#3");
  70
  71                         value = new RangeHeaderValue (2, 4);
  72                         Assert.AreEqual (value, new RangeHeaderValue (2, 4), "#4");
  73                         Assert.AreNotEqual (value, new RangeHeaderValue (2, null), "#5");
  74                         Assert.AreNotEqual (value, new RangeHeaderValue (2, 3), "#6");
  75                 }
  76
  77                 [Test]
  78                 public void Parse ()
  79                 {
  80                         var res = RangeHeaderValue.Parse ("bytes=2-40");
  81                         Assert.AreEqual ("bytes", res.Unit, "#1");
  82                         Assert.AreEqual (2, res.Ranges.First ().From, "#2");
  83                         Assert.AreEqual (40, res.Ranges.First ().To, "#3");
  84                         Assert.AreEqual ("bytes=2-40", res.ToString (), "#4");
  85
  86                         res = RangeHeaderValue.Parse ("d-dd = 2 - ");
  87                         Assert.AreEqual ("d-dd", res.Unit, "#10");
  88                         Assert.AreEqual (2, res.Ranges.First ().From, "#11");
  89                         Assert.IsNull (res.Ranges.First ().To, "#12");
  90                         Assert.AreEqual ("d-dd=2-", res.ToString (), "#13");
  91
  92                         res = RangeHeaderValue.Parse ("zz = - 6 , 5 - 9, -8");
  93                         Assert.AreEqual ("zz", res.Unit, "#20");
  94                         Assert.IsNull (res.Ranges.First ().From, "#21");
  95                         Assert.AreEqual (6, res.Ranges.First ().To, "#22");
  96                         Assert.AreEqual (5, res.Ranges.Skip (1).First ().From, "#21b");
  97                         Assert.AreEqual (9, res.Ranges.Skip (1).First ().To, "#22b");
  98                         Assert.AreEqual ("zz=-6, 5-9, -8", res.ToString (), "#23");
  99
 100                         res = RangeHeaderValue.Parse ("ddd = 2 -, 1-4");
 101                         Assert.AreEqual ("ddd", res.Unit, "#30");
 102                         Assert.AreEqual (2, res.Ranges.First ().From, "#31");
 103                         Assert.IsNull (res.Ranges.First ().To, "#32");
 104                         Assert.AreEqual ("ddd=2-, 1-4", res.ToString (), "#33");
 105
 106                         res = RangeHeaderValue.Parse ("bytes=0-");
 107                         Assert.AreEqual ("bytes", res.Unit, "#40");
 108                         Assert.AreEqual (0, res.Ranges.First ().From, "#41");
 109                         Assert.IsNull (res.Ranges.First ().To, "#42");
 110                         Assert.AreEqual ("bytes=0-", res.ToString (), "#43");
 111
 112                         res = RangeHeaderValue.Parse ("bytes=0-,-9");
 113                         Assert.AreEqual ("bytes", res.Unit, "#50");
 114                         Assert.AreEqual (0, res.Ranges.First ().From, "#51");
 115                         Assert.IsNull (res.Ranges.First ().To, "#52");
 116                         Assert.IsNull (res.Ranges.Skip (1).First ().From, "#53");
 117                         Assert.AreEqual (9, res.Ranges.Skip (1).First ().To, "#54");
 118                         Assert.AreEqual ("bytes=0-, -9", res.ToString (), "#55");
 119                 }
 120
 121                 [Test]
 122                 public void Parse_Invalid ()
 123                 {
 124                         try {
 125                                 RangeHeaderValue.Parse (null);
 126                                 Assert.Fail ("#1");
 127                         } catch (FormatException) {
 128                         }
 129
 130                         try {
 131                                 RangeHeaderValue.Parse ("  ");
 132                                 Assert.Fail ("#2");
 133                         } catch (FormatException) {
 134                         }
 135
 136                         try {
 137                                 RangeHeaderValue.Parse ("5-6");
 138                                 Assert.Fail ("#3");
 139                         } catch (FormatException) {
 140                         }
 141
 142                         try {
 143                                 RangeHeaderValue.Parse ("bytes=");
 144                                 Assert.Fail ("#4");
 145                         } catch (FormatException) {
 146                         }
 147
 148                         try {
 149                                 RangeHeaderValue.Parse ("byte=1");
 150                                 Assert.Fail ("#5");
 151                         } catch (FormatException) {
 152                         }
 153
 154                         try {
 155                                 RangeHeaderValue.Parse ("byte=10-6");
 156                                 Assert.Fail ("#6");
 157                         } catch (FormatException) {
 158                         }
 159                 }
 160
 161                 [Test]
 162                 public void Properties ()
 163                 {
 164                         var value = new RangeHeaderValue (3, 9);
 165                         Assert.AreEqual ("bytes", value.Unit, "#1");
 166                         Assert.AreEqual (3, value.Ranges.First ().From, "#2");
 167                         Assert.AreEqual (9, value.Ranges.First ().To, "#3");
 168
 169                         value = new RangeHeaderValue ();
 170                         Assert.AreEqual ("bytes", value.Unit, "#4");
 171                         Assert.AreEqual (0, value.Ranges.Count, "#5");
 172                 }
 173
 174                 [Test]
 175                 public void Properties_Invalid ()
 176                 {
 177                         var value = new RangeHeaderValue ();
 178                         try {
 179                                 value.Unit = "";
 180                                 Assert.Fail ("#1");
 181                         } catch (ArgumentException) {
 182                         }
 183                 }
 184
 185                 [Test]
 186                 public void TryParse ()
 187                 {
 188                         RangeHeaderValue res;
 189                         Assert.IsTrue (RangeHeaderValue.TryParse ("bytes=4-33", out res), "#1");
 190                         Assert.AreEqual ("bytes", res.Unit, "#2");
 191                         Assert.AreEqual (4, res.Ranges.First ().From, "#3");
 192                         Assert.AreEqual (33, res.Ranges.First ().To, "#4");
 193                 }
 194
 195                 [Test]
 196                 public void TryParse_Invalid ()
 197                 {
 198                         RangeHeaderValue res;
 199                         Assert.IsFalse (RangeHeaderValue.TryParse ("bytes=4,33", out res), "#1");
 200                         Assert.IsNull (res, "#2");
 201                 }
 202         }
 203 }