Tools/NVelocity/src/NVelocity.Tests/MultiThreadTestCase.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace NVelocity
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.IO;
  20         using System.Text.RegularExpressions;
  21         using System.Threading;
  22         using App;
  23         using NUnit.Framework;
  24         using Test;
  25
  26         [TestFixture, Explicit]
  27         public class MultiThreadTestCase
  28         {
  29                 private ManualResetEvent startEvent = new ManualResetEvent(false);
  30                 private ManualResetEvent stopEvent = new ManualResetEvent(false);
  31                 private ArrayList items;
  32                 private VelocityEngine ve;
  33
  34                 [SetUp]
  35                 public void Setup()
  36                 {
  37                         items = new ArrayList();
  38
  39                         items.Add("a");
  40                         items.Add("b");
  41                         items.Add("c");
  42                         items.Add("d");
  43
  44                         ve = new VelocityEngine();
  45                         ve.Init();
  46                 }
  47
  48                 [Test]
  49                 public void Multithreaded_ASTExecuteDoesNotShareParams()
  50                 {
  51                         const int threadCount = 1;
  52
  53                         Thread[] threads = new Thread[threadCount];
  54
  55                         for (int i = 0; i < threadCount; i++)
  56                         {
  57                                 threads[i] = new Thread(ExecuteMethodUntilSignal3);
  58                                 threads[i].Start();
  59                         }
  60
  61                         startEvent.Set();
  62
  63                         Thread.CurrentThread.Join(3*5000);
  64
  65                         stopEvent.Set();
  66                 }
  67
  68                 [Test]
  69                 public void Multithreaded1()
  70                 {
  71                         const int threadCount = 30;
  72
  73                         Thread[] threads = new Thread[threadCount];
  74
  75                         for (int i = 0; i < threadCount; i++)
  76                         {
  77                                 threads[i] = new Thread(ExecuteMethodUntilSignal1);
  78                                 threads[i].Start();
  79                         }
  80
  81                         startEvent.Set();
  82
  83                         Thread.CurrentThread.Join(1*5000);
  84
  85                         stopEvent.Set();
  86                 }
  87
  88                 [Test]
  89                 public void Multithreaded_ReuseVelocityEngineInstanceConcurrently()
  90                 {
  91                         const int threadCount = 30;
  92
  93                         Thread[] threads = new Thread[threadCount];
  94
  95                         for (int i = 0; i < threadCount; i++)
  96                         {
  97                                 threads[i] = new Thread(ExecuteMethodUntilSignal2);
  98                                 threads[i].Start();
  99                         }
 100
 101                         startEvent.Set();
 102
 103                         Thread.CurrentThread.Join(1*5000);
 104
 105                         stopEvent.Set();
 106                 }
 107
 108                 /// <summary>
 109                 /// This test starts a VelocityEngine for each execution
 110                 /// </summary>
 111                 public void ExecuteMethodUntilSignal1()
 112                 {
 113                         startEvent.WaitOne(int.MaxValue, false);
 114
 115                         while (!stopEvent.WaitOne(0, false))
 116                         {
 117                                 VelocityEngine ve = new VelocityEngine();
 118                                 ve.Init();
 119
 120                                 StringWriter sw = new StringWriter();
 121
 122                                 VelocityContext c = new VelocityContext();
 123                                 c.Put("x", new Something());
 124                                 c.Put("items", items);
 125
 126                                 bool ok = ve.Evaluate(c, sw,
 127                                                       "ContextTest.CaseInsensitive",
 128                                                       @"
 129                                         #foreach( $item in $items )
 130                                                 $item,
 131                                         #end
 132                                 ");
 133
 134                                 Assert.IsTrue(ok, "Evalutation returned failure");
 135                                 Assert.AreEqual("a,b,c,d,", Normalize(sw));
 136                         }
 137                 }
 138
 139                 /// <summary>
 140                 /// This test uses the previously created velocity engine
 141                 /// </summary>
 142                 public void ExecuteMethodUntilSignal2()
 143                 {
 144                         startEvent.WaitOne(int.MaxValue, false);
 145
 146                         while (!stopEvent.WaitOne(0, false))
 147                         {
 148                                 StringWriter sw = new StringWriter();
 149
 150                                 VelocityContext c = new VelocityContext();
 151                                 c.Put("x", new Something());
 152                                 c.Put("items", items);
 153
 154                                 bool ok = ve.Evaluate(c, sw,
 155                                                       "ContextTest.CaseInsensitive",
 156                                                       @"
 157                                         #foreach($item in $items)
 158                                                 $item,
 159                                         #end
 160
 161                                         $x.Print('hey') $x.Contents('test', '1')
 162                                 ");
 163
 164                                 Assert.IsTrue(ok, "Evalutation returned failure");
 165                                 Assert.AreEqual("a,b,c,d,heytest,1", Normalize(sw));
 166                         }
 167                 }
 168
 169                 public void ExecuteMethodUntilSignal3()
 170                 {
 171                         startEvent.WaitOne(int.MaxValue, false);
 172
 173                         try
 174                         {
 175                                 while (!stopEvent.WaitOne(0, false))
 176                                 {
 177                                         StringWriter sw = new StringWriter();
 178
 179                                         VelocityContext c = new VelocityContext();
 180                                         c.Put("x", new Urlhelper());
 181
 182                                         bool ok = ve.Evaluate(c, sw, "",
 183                                                               "#foreach($i in [1..3000]) \r\n" +
 184                                                               "#set($temp = $x.For(\"%{controller='Test',id=$i}\")) \r\n" +
 185                                                               "#end \r\n");
 186
 187                                         Assert.IsTrue(ok, "Evalutation returned failure");
 188                                 }
 189                         }
 190                         catch(System.Exception ex)
 191                         {
 192                                 Console.WriteLine(ex.ToString());
 193                         }
 194                 }
 195
 196                 private string Normalize(StringWriter sw)
 197                 {
 198                         return Regex.Replace(sw.ToString(), "\\s+", "");
 199                 }
 200
 201                 private class Urlhelper
 202                 {
 203                         public string For(IDictionary parameters)
 204                         {
 205                                 if (parameters == null)
 206                                 {
 207                                         throw new ArgumentNullException("parameters", "parameters cannot be null");
 208                                 }
 209
 210                                 try
 211                                 {
 212                                         string controller = (string) parameters["controller"];
 213                                         int id = (int) parameters["id"];
 214
 215                                         parameters.Remove("controller");
 216                                         parameters.Remove("id");
 217
 218                                         return controller + " " + id;
 219                                 }
 220                                 catch (System.Exception ex)
 221                                 {
 222                                         Console.WriteLine(ex.ToString());
 223                                         throw;
 224                                 }
 225                         }
 226                 }
 227         }
 228 }