mcs/class/System/Test/System.Net.Sockets/MulticastOptionTest.cs

   1 // System.Net.Sockets.MulticastOptionTest.cs
   2 //
   3 // Authors:
   4 //      Gert Driesen (drieseng@users.sourceforge.net)
   5 //
   6 // Copyright (c) 2009 Gert Driesen
   7 //
   8
   9 using System;
  10 using System.Net;
  11 using System.Net.Sockets;
  12
  13 using NUnit.Framework;
  14
  15 namespace MonoTests.System.Net.Sockets
  16 {
  17         [TestFixture]
  18         public class MulticastOptionTest
  19         {
  20                 [Test] // .ctor (IPAddress)
  21                 public void Constructor1 ()
  22                 {
  23                         MulticastOption option;
  24                         IPAddress group;
  25
  26                         group = IPAddress.Parse ("239.255.255.250");
  27                         option = new MulticastOption (group);
  28                         Assert.AreSame (group, option.Group, "#A:Group");
  29 #if NET_2_0
  30                         Assert.AreEqual (0, option.InterfaceIndex, "#A:InterfaceIndex");
  31 #endif
  32                         Assert.AreEqual (IPAddress.Any, option.LocalAddress, "#A:LocalAddress");
  33
  34                         group = IPAddress.Parse ("ff02::1");
  35                         option = new MulticastOption (group);
  36                         Assert.AreSame (group, option.Group, "#B:Group");
  37 #if NET_2_0
  38                         Assert.AreEqual (0, option.InterfaceIndex, "#B:InterfaceIndex");
  39 #endif
  40                         Assert.AreEqual (IPAddress.Any, option.LocalAddress, "#B:LocalAddress");
  41                 }
  42
  43                 [Test] // .ctor (IPAddress)
  44                 public void Constructor1_Group_Null ()
  45                 {
  46                         try {
  47                                 new MulticastOption ((IPAddress) null);
  48                                 Assert.Fail ("#1");
  49                         } catch (ArgumentNullException ex) {
  50                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  51                                 Assert.IsNull (ex.InnerException, "#3");
  52                                 Assert.IsNotNull (ex.Message, "#4");
  53                                 Assert.AreEqual ("group", ex.ParamName, "#5");
  54                         }
  55                 }
  56
  57                 [Test] // .ctor (IPAddress, IPAddress)
  58                 public void Constructor2 ()
  59                 {
  60                         MulticastOption option;
  61                         IPAddress group;
  62                         IPAddress mcint;
  63
  64                         group = IPAddress.Parse ("239.255.255.250");
  65                         mcint = IPAddress.Any;
  66                         option = new MulticastOption (group, mcint);
  67                         Assert.AreSame (group, option.Group, "#A:Group");
  68 #if NET_2_0
  69                         Assert.AreEqual (0, option.InterfaceIndex, "#A:InterfaceIndex");
  70 #endif
  71                         Assert.AreEqual (mcint, option.LocalAddress, "#A:LocalAddress");
  72
  73                         group = IPAddress.Parse ("ff02::1");
  74                         mcint = IPAddress.IPv6Any;
  75                         option = new MulticastOption (group, mcint);
  76                         Assert.AreSame (group, option.Group, "#B:Group");
  77 #if NET_2_0
  78                         Assert.AreEqual (0, option.InterfaceIndex, "#B:InterfaceIndex");
  79 #endif
  80                         Assert.AreEqual (mcint, option.LocalAddress, "#B:LocalAddress");
  81                 }
  82
  83                 [Test] // .ctor (IPAddress, IPAddress)
  84                 public void Constructor2_Group_Null ()
  85                 {
  86                         IPAddress group = null;
  87                         IPAddress mcint = IPAddress.Any;
  88
  89                         try {
  90                                 new MulticastOption (group, mcint);
  91                                 Assert.Fail ("#1");
  92                         } catch (ArgumentNullException ex) {
  93                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  94                                 Assert.IsNull (ex.InnerException, "#3");
  95                                 Assert.IsNotNull (ex.Message, "#4");
  96                                 Assert.AreEqual ("group", ex.ParamName, "#5");
  97                         }
  98                 }
  99
 100                 [Test] // .ctor (IPAddress, IPAddress)
 101                 public void Constructor2_Mcint_Null ()
 102                 {
 103                         IPAddress group = IPAddress.Parse ("239.255.255.250");
 104                         IPAddress mcint = null;
 105
 106                         try {
 107                                 new MulticastOption (group, mcint);
 108                                 Assert.Fail ("#1");
 109                         } catch (ArgumentNullException ex) {
 110                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 111                                 Assert.IsNull (ex.InnerException, "#3");
 112                                 Assert.IsNotNull (ex.Message, "#4");
 113                                 Assert.AreEqual ("mcint", ex.ParamName, "#5");
 114                         }
 115                 }
 116
 117 #if NET_2_0
 118                 [Test] // .ctor (IPAddress, Int32)
 119                 public void Constructor3 ()
 120                 {
 121                         MulticastOption option;
 122                         IPAddress group;
 123                         int interfaceIndex;
 124
 125                         group = IPAddress.Parse ("239.255.255.250");
 126                         interfaceIndex = 0;
 127                         option = new MulticastOption (group, interfaceIndex);
 128                         Assert.AreSame (group, option.Group, "#A:Group");
 129                         Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#A:InterfaceIndex");
 130                         Assert.AreEqual (null, option.LocalAddress, "#A:LocalAddress");
 131
 132                         group = IPAddress.Parse ("ff02::1");
 133                         interfaceIndex = 0;
 134                         option = new MulticastOption (group, interfaceIndex);
 135                         Assert.AreSame (group, option.Group, "#B:Group");
 136                         Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#B:InterfaceIndex");
 137                         Assert.AreEqual (null, option.LocalAddress, "#B:LocalAddress");
 138
 139                         group = IPAddress.Parse ("239.255.255.250");
 140                         interfaceIndex = 124;
 141                         option = new MulticastOption (group, interfaceIndex);
 142                         Assert.AreSame (group, option.Group, "#C:Group");
 143                         Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#C:InterfaceIndex");
 144                         Assert.AreEqual (null, option.LocalAddress, "#C:LocalAddress");
 145
 146                         group = IPAddress.Parse ("ff02::1");
 147                         interfaceIndex = 124;
 148                         option = new MulticastOption (group, interfaceIndex);
 149                         Assert.AreSame (group, option.Group, "#D:Group");
 150                         Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#D:InterfaceIndex");
 151                         Assert.AreEqual (null, option.LocalAddress, "#D:LocalAddress");
 152
 153                         group = IPAddress.Parse ("239.255.255.250");
 154                         interfaceIndex = 0xFFFFFF;
 155                         option = new MulticastOption (group, interfaceIndex);
 156                         Assert.AreSame (group, option.Group, "#E:Group");
 157                         Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#E:InterfaceIndex");
 158                         Assert.AreEqual (null, option.LocalAddress, "#E:LocalAddress");
 159
 160                         group = IPAddress.Parse ("ff02::1");
 161                         interfaceIndex = 0xFFFFFF;
 162                         option = new MulticastOption (group, interfaceIndex);
 163                         Assert.AreSame (group, option.Group, "#F:Group");
 164                         Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#F:InterfaceIndex");
 165                         Assert.AreEqual (null, option.LocalAddress, "#F:LocalAddress");
 166                 }
 167
 168                 [Test] // .ctor (IPAddress, Int32)
 169                 public void Constructor3_Group_Null ()
 170                 {
 171                         IPAddress group = null;
 172
 173                         try {
 174                                 new MulticastOption (group, int.MaxValue);
 175                                 Assert.Fail ("#1");
 176                         } catch (ArgumentNullException ex) {
 177                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 178                                 Assert.IsNull (ex.InnerException, "#3");
 179                                 Assert.IsNotNull (ex.Message, "#4");
 180                                 Assert.AreEqual ("group", ex.ParamName, "#5");
 181                         }
 182                 }
 183
 184                 [Test] // .ctor (IPAddress, Int32)
 185                 public void Constructor3_InterfaceIndex_OutOfRange ()
 186                 {
 187                         IPAddress group = IPAddress.Parse ("239.255.255.250");
 188
 189                         try {
 190                                 new MulticastOption (group, -1);
 191                                 Assert.Fail ("#A1");
 192                         } catch (ArgumentOutOfRangeException ex) {
 193                                 // Specified argument was out of the range of valid values
 194                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 195                                 Assert.IsNull (ex.InnerException, "#A3");
 196                                 Assert.IsNotNull (ex.Message, "#A4");
 197                                 Assert.AreEqual ("interfaceIndex", ex.ParamName, "#A5");
 198                         }
 199
 200                         try {
 201                                 new MulticastOption (group, 0x1000000);
 202                                 Assert.Fail ("#B1");
 203                         } catch (ArgumentOutOfRangeException ex) {
 204                                 // Specified argument was out of the range of valid values
 205                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 206                                 Assert.IsNull (ex.InnerException, "#B3");
 207                                 Assert.IsNotNull (ex.Message, "#B4");
 208                                 Assert.AreEqual ("interfaceIndex", ex.ParamName, "#B5");
 209                         }
 210                 }
 211 #endif
 212
 213                 [Test]
 214                 public void Group ()
 215                 {
 216                         IPAddress group;
 217                         IPAddress local;
 218                         MulticastOption option;
 219
 220 #if NET_2_0
 221                         local = Dns.GetHostEntry (string.Empty).AddressList [0];
 222 #else
 223                         local = IPAddress.Loopback;
 224 #endif
 225                         group = IPAddress.Parse ("239.255.255.250");
 226                         option = new MulticastOption (group, local);
 227                         group = IPAddress.Parse ("224.0.0.23");
 228                         option.Group = group;
 229                         Assert.AreSame (group, option.Group, "#A1");
 230                         Assert.AreSame (local, option.LocalAddress, "#A2");
 231                         group = IPAddress.Parse ("239.255.255.250");
 232                         option.Group = group;
 233                         Assert.AreSame (group, option.Group, "#B1");
 234                         Assert.AreSame (local, option.LocalAddress, "#B2");
 235                         group = IPAddress.Parse ("ff02::1");
 236                         option.Group = group;
 237                         Assert.AreSame (group, option.Group, "#C1");
 238                         Assert.AreSame (local, option.LocalAddress, "#C2");
 239                         option.Group = null;
 240                         Assert.IsNull (option.Group, "#D1");
 241                         Assert.AreSame (local, option.LocalAddress, "#D2");
 242 #if NET_2_0
 243                         option = new MulticastOption (group, 5);
 244                         group = IPAddress.Parse ("224.0.0.23");
 245                         option.Group = group;
 246                         Assert.AreSame (group, option.Group, "#E1");
 247                         Assert.AreEqual (5, option.InterfaceIndex, "#E2");
 248                         Assert.IsNull (option.LocalAddress, "#E3");
 249 #endif
 250                 }
 251
 252 #if NET_2_0
 253                 [Test]
 254                 public void InterfaceIndex ()
 255                 {
 256                         IPAddress group;
 257                         IPAddress local;
 258                         MulticastOption option;
 259
 260                         group = IPAddress.Parse ("239.255.255.250");
 261                         option = new MulticastOption (group, 10);
 262                         option.InterfaceIndex = 0;
 263                         Assert.AreSame (group, option.Group, "#A1");
 264                         Assert.AreEqual (0, option.InterfaceIndex, "#A2");
 265                         Assert.IsNull (option.LocalAddress, "#A3");
 266                         option.InterfaceIndex = 124;
 267                         Assert.AreSame (group, option.Group, "#B1");
 268                         Assert.AreEqual (124, option.InterfaceIndex, "#B2");
 269                         Assert.IsNull (option.LocalAddress, "#B3");
 270                         option.InterfaceIndex = 0xFFFFFF;
 271                         Assert.AreSame (group, option.Group, "#C1");
 272                         Assert.AreEqual (0xFFFFFF, option.InterfaceIndex, "#C2");
 273                         Assert.IsNull (option.LocalAddress, "#C3");
 274
 275                         local = Dns.GetHostEntry (string.Empty).AddressList [0];
 276                         option = new MulticastOption (group, local);
 277                         option.InterfaceIndex = 10;
 278                         Assert.AreSame (group, option.Group, "#D1");
 279                         Assert.AreEqual (10, option.InterfaceIndex, "#D2");
 280                         Assert.IsNull (option.LocalAddress, "#D3");
 281                 }
 282
 283                 [Test]
 284                 public void InterfaceIndex_Value_OutOfRange ()
 285                 {
 286                         IPAddress group = IPAddress.Parse ("239.255.255.250");
 287                         MulticastOption option = new MulticastOption (group, 10);
 288
 289                         try {
 290                                 option.InterfaceIndex = -1;
 291                                 Assert.Fail ("#A1");
 292                         } catch (ArgumentOutOfRangeException ex) {
 293                                 // Specified argument was out of the range of valid values
 294                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 295                                 Assert.IsNull (ex.InnerException, "#A3");
 296                                 Assert.IsNotNull (ex.Message, "#A4");
 297                                 Assert.AreEqual ("value", ex.ParamName, "#A5");
 298                         }
 299
 300                         try {
 301                                 option.InterfaceIndex = 0x1000000;
 302                                 Assert.Fail ("#B1");
 303                         } catch (ArgumentOutOfRangeException ex) {
 304                                 // Specified argument was out of the range of valid values
 305                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 306                                 Assert.IsNull (ex.InnerException, "#B3");
 307                                 Assert.IsNotNull (ex.Message, "#B4");
 308                                 Assert.AreEqual ("value", ex.ParamName, "#B5");
 309                         }
 310
 311                         // ensure original value was retained
 312                         Assert.AreEqual (10, option.InterfaceIndex, "#C");
 313                 }
 314 #endif
 315
 316                 [Test]
 317                 public void LocalAddress ()
 318                 {
 319                         IPAddress group;
 320                         IPAddress local;
 321                         MulticastOption option;
 322
 323 #if NET_2_0
 324                         local = Dns.GetHostEntry (string.Empty).AddressList [0];
 325 #else
 326                         local = IPAddress.Loopback;
 327 #endif
 328                         group = IPAddress.Parse ("239.255.255.250");
 329                         option = new MulticastOption (group, local);
 330                         local = IPAddress.Loopback;
 331                         option.LocalAddress = local;
 332                         Assert.AreSame (group, option.Group, "#A1");
 333 #if NET_2_0
 334                         Assert.AreEqual (0, option.InterfaceIndex, "#A2");
 335 #endif
 336                         Assert.AreSame (local, option.LocalAddress, "#A3");
 337 #if NET_2_0
 338                         local = Dns.GetHostEntry (string.Empty).AddressList [0];
 339 #else
 340                         local = IPAddress.Loopback;
 341 #endif
 342                         option.LocalAddress = local;
 343                         Assert.AreSame (group, option.Group, "#B1");
 344 #if NET_2_0
 345                         Assert.AreEqual (0, option.InterfaceIndex, "#B2");
 346 #endif
 347                         Assert.AreSame (local, option.LocalAddress, "#B3");
 348                         option.LocalAddress = null;
 349                         Assert.AreSame (group, option.Group, "#C1");
 350 #if NET_2_0
 351                         Assert.AreEqual (0, option.InterfaceIndex, "#C2");
 352 #endif
 353                         Assert.IsNull (option.LocalAddress, "#C3");
 354 #if NET_2_0
 355                         option = new MulticastOption (group, 5);
 356                         local = IPAddress.Loopback;
 357                         option.LocalAddress = local;
 358                         Assert.AreSame (group, option.Group, "#D1");
 359                         Assert.AreEqual (0, option.InterfaceIndex, "#D2");
 360                         Assert.AreSame (local, option.LocalAddress, "#D3");
 361 #endif
 362                 }
 363         }
 364 }