text:
Little intro
Reflector is a (great) decompiler. The most obvious use of it is to load an assembly and recreate source code out of the IL it contains. The assembly itself was built from source code, so we have a mini "cycle of life". In a perfect world, the decompiled code and the orginal source code would be exactly the same (at least in the same language). So we can represent this cycle by the figure below.
Now, let's introduce a new actor in this ecosystem. We want the decompiler to producec CodeDom source code that can be used to generate the original source code as shown in the figure below: we want to produce a CodeDom template that will generate that type.
Sample example
Let's illustrate all this with an example. Consider the following User class:
public class User
private string name = "Marc";
public String Name
return this.name;
public override string ToString()
return this.name;
We compile User and now, we want Reflector to generate a class that uses CodeDom (indeed Refly) to generate back the User class. This is the tricky part. I need to use Refly to generate code that uses Refly, so that would be building a code generator generator. The template for the User class will look like this:
public class UserTemplate
private Refly.CodeDom.ClassDeclaration _type;
private Refly.CodeDom.FieldDeclaration _nameField;
private Refly.CodeDom.PropertyDeclaration _nameProperty;
private Refly.CodeDom.MethodDeclaration _toStringMethod;
public UserTemplate(Refly.CodeDom.NamespaceDeclaration ns)
// add User class to generator
this._type = ns.AddClass("User");
public virtual void Declare()
public virtual void DeclareFields()
// adding name field
this._nameField = this._type.AddField(typeof(String), "name");
public virtual void DeclareMethods()
this._toStringMethod = this._type.AddMethod("ToString");
public virtual void DeclareProperties()
this._nameProperty = this._type.AddProperty(typeof(String), "Name");
(The above template is still missing a big part: the generation of the statements and the expression) Now that we have a Refly ClassDeclaration, we can feed it to the CodeGenerator class:
NamespaceDeclaration ns = new NamespaceDeclaration("RoundRobin");
UserTemplate template = new UserTemplate(ns);
CodeGenerator gen =new CodeGenerator();
And the result of the execution of this program will be this piece of code:
namespace RoundRobin
using System;
public class User
private string _name;
public virtual string Name
public virtual void ToString()
Not so bad for a start, we have gotten our User class back but there are still some big "holes" in it....
Following the idea of displaying a class in a PropertyGrid, we can also take a look at how it serializes using the XmlSerializer (see if it serializes at all!). The task looks trivial at first sight:
Of course, there's a gotcha here. You will likely get empty xml files all of the time because usually, the default constructor creates "empty" object. So what we want is to dress the object before serializing them. This is done in a variety of ways depending on the property type:
Of course, this is rather simplistic and may fail on forgotten situations.
Screenshot: ReportAssembly contains collection properties (namespaces, fixtures), which would appear empty if not "dressed".
In this blog, I'll show how you can a implement a control to colorizes XML in a simple and effective way. I needed to display XML in a control, however, displaying it in "black and white" made it very depressing. I have 3 objectives: simplicity, simplicity and simplicity.You can think of this as a traditional Microsoft interview enigma. So let's enumerate what we need and what we want (and what we want to avoid).
What we want: colors!What we don't want: manipulate the XML Dom, in other words: let's be lazy.What we have: it's time to dig into the FCL classes and see what we could use
At this point, you must have an idea of the way we are going to acheive colors... the tools are here, we just need to inject the color at the right spot (like in a toothpaste, the color lines come right at the end). In fact, we have 3 tasks to acheive:
1) RichTextBoxWriter:
A TextWriter-derived class that writes to a RichTextBox. The writer keeps a current Color and Font that is apply to each chunk of string appended. This task is pretty straightforward, basically you need to overload 3 Write methods.
public class RichTextBoxWriter : TextWriter
private RichTextBox textBox;
private Color currentColor=Color.Black;
private Font currentFont = new Font("Tahoma",8.25f);
public override void Write(char value)
this.TextBox.SelectedText = value.ToString(this.FormatProvider);
public override void Write(char[] buffer)
if (buffer!=null)
this.TextBox.SelectedText = new String(buffer).ToString(this.FormatProvider);
// if buffer = '\n\r', font and color is reseted
public override void Write(string value)
this.TextBox.SelectedText = value.ToString(this.FormatProvider);
Wow, that was short. Now to point 2.
2) XmlRichTextWriter:
This class, which inherits from XmlTextWriter, injects color on some "startegic" methods. In order to store the colors, we create XmlRichTextBox, which inherits from RichTextBox and contains a rich set of customizable colors and fonts for the Xml rendering. This class will be used by the XmlRichTextBoxWriter:
public class XmlRichTextBoxWriter : XmlTextWriter
private XmlRichTextBox theme; // contains all the colors and fonts
public XmlRichTextBoxWriter(XmlRichTextBox tb)
public override void WriteStartDocument()
// setting color of the selected text
this.theme.Writer.CurrentColor = this.theme.StartColor;
this.theme.Writer.CurrentFont = this.theme.StartFont;
// output data
4) XmlRichTextBox:
Now, that we have our writer, we just need to wire them up in the XmlRichTextBox and we are done.
And finally, the result: on the left, a XmlRichTextBox, on the left, how it looks like in the PropertyGrid. We have colooors!
Download it now....
Joel Pobar speaks about the new features of Reflection.
ReflectionOnly seems to be very interresting...
Ever wondered how you classes you look like in a PropertyGrid control, now it is possible directly from Reflector with my upcoming Reflector Addin:
Ps: As always, a big thanks to Jamie Cansdale (NUnitAddIn) for his help on this one.
XsdTidy is a refactoring tool to overcomes some silly limitations of the exceptional Xsd.exe tool provided with the .NET framework. More specifically, XsdTidy addresses the following problems:
Note that XsdTidy uses Refly for building the source code and is also maintained by Marcus Mac Innes.
What does XsdTidy fix ?
Name conversion
The .NET standards define specific naming convention for all types of data: arguments should be camel case, function names capitalized, etc... This is really helpful to keep the framework consistent. Tools like FxCop help us stay on the "normalized" side.
This problem is tackled the dumb way: given a dictionary of "common" words, the class NameConformer tries to split a name in separate words, after that it renders it to the needed convention. Of couse, this feature can be disabled.
FixedArraySize and "Multi" Strongly-Typed Collections
Arrays are replaced by inner strongly-type collections which are much more flexible to use. Moreover, array fields are created by default using their default constructor. This is to economize you the hassle of creating a collection before using it. If an array can support multiple object type, the generate collection will be "multi" strongly typed:
public class TestClass
public Object[] values;
public class TestClass
private ValueCollection values = new ValueCollection();
public ValueCollection Values
get { return this.values;}
public class ValueCollection : CollectionBase
public void AddCar(Car car)
public void AddBike(Bike bike)
... // the implementation of the collection
Fields are hidden in properties, which is more convenient to use. Moreover, collection fields do not have set property according to FxCop rule.
public class testclass
public String values;
public class TestClass
private String values;
public String Values
return this.values;
this.values = value;
The output classes are tagged with the Serializable attribute to make them usable using Remoting.
XsdTidy history
I have first started to build XsdTidy using System.Reflection.Emit. It was a titanic job and very error prone. The difficulty of using Emit pushed me to use CodeDom which was also heavy to use. So finally, Refly was designed and XsdTidy became much easier to impement.
Download XsdTidy and Refly at http://blog.dotnetwiki.org/downloads/Refly.zip
Reflector.Graph was becoming messy because of external dependencies so I decided to remove some parts of it (TypeGraph, TreeMap) in order to keep funcitonal.
Reflector version: tested for 126.96.36.199 and 18.104.22.168
Installation procedure:
In this release, you do not need to create a Reflector.exe.config.
What's in Reflector.Graph:
What's not in Reflector.Graph:
Bugs and suggestions:
The Database Populator Framework follows the same idea of DbMonster (or at least, was partially inspired from it). The purpose of the framework is to provide a flexible (and smart) set of random data generators to populate your database.
Why ?
If you plan to do database testing, the solution are not much: use transaction, create/kill database after each unit test, clean up after each test or use the new technique using Enterprise Services.
The objective of DPF is not to test the database but provide "food" for your unit test. By generating data randomly (satisfying the constraint), you do not need to clean up and you will avoid test clashing on each other. Moreover, you can also use the DPF to test your database under load.
Random but no dumb
In order to generate data for testing database, you need to take into accounts the constraints on the columns and between the tables. By providing a DataSet representing you database, the framework analyses it and create a set of generators. The data generated satisfies all the constraint. Of course, each row generator can be customized for your own needs, but in general, the information contained in the dataset is enough.
The ideas
The idea are rather simple:
The generation of a new row is made inside a ITablePopulator as follows:
The first bits
The first bits of the framework is located in the MbUnit.Framework.Data namespace. Althout the framework still needs work, the first example is running and is quite promising.
I have built a simple database containing User - Order - Product - OrderProduct:
this.dataSet=new DataSet();
DataTable users=dataSet.Tables.Add("Users");
DataColumn userID = users.Columns.Add("UserID",typeof(int));
DataColumn userName=Users.Columns.Add("UserName",typeof(string));
DataColumn userName.AllowDBNull=false;
DataTable orders=dataSet.Tables.Add("Orders");
DataColumn orderID=orders.Columns.Add("OrderID",typeof(int));
DataColumn orderDate = orders.Columns.Add("OrderDate",typeof(DateTime));
DataColumn oUserID = orders.Columns.Add("UserID",typeof(int));
DataTable products=dataSet.Tables.Add("Products");
DataColumn productID=products.Columns.Add("ProductID",typeof(int));
DataColumn productName = products.Columns.Add("ProductName",typeof(string));
DataColumn productPrice = products.Columns.Add("ProductPrice",typeof(decimal));
DataTable orderProducts=dataSet.Tables.Add("OrderProducts");
DataColumn opOrderID=orderProducts.Columns.Add("OrderID",typeof(int));
DataColumn opProductID=orderProducts.Columns.Add("ProductID",typeof(int));
DataColumn quantity=orderProducts.Columns.Add("Quantity",typeof(int));
// pks
new DataColumn[]{ opOrderID, opProductID}
// fks
This database is easily populated using the DPF:
// creating populator
IDatabasePopulator pop=new DatabasePopulator();
// anaylising internal structure
After that, you can customize the behavior of every data generator. Once this is done, you are ready to "feed" your database:
//getting the users table populator
ITablePopulator userPop = pop.Tables[users];
// adding new row
users.Rows.Add( userPop.Generate() );
Refly is the library that I have developped to make CodeDom usable. (See my CodeProject article here, or the classic Hello World example). Note that Refly comes with XsdTidy, an application that "pretify" the output of the Xml.exe tool.
Download Now
If you are doing database testing, you should read this great post by Roy:
Simplified Database Unit testing using Enterprise Services
The Production Grammar Framework is finally fully integrated into MbUnit as a new Fixture (GrammarFixture).
An example:
I'm currently building a new framework for generating "relevant" data for randomly populating database (similar ideas to DbMonster). As you may have noticed, I don't practive dogfood much so I decided to start now. I'm writing the test code along with the framework (of course, I'm testing myself here so it's a bit twisted). Anyway, I had to test the following collection:
public interface IDataGeneratorCollection : ICollection
IDataGenerator this[DataColumn column]{get;}
IDataGenerator this[String columnName]{get;}
void Add(IDataGenerator dataGenerator);
void Remove(IDataGenerator dataGenerator);
void Remove(DataColumn column);
void Remove(String columnName);
bool Contains(IDataGenerator dataGenerator);
bool Contains(DataColumn column);
bool Contains(String columnName);
void Clear();
At first, I decided to write a TypeFixture and produce a bunch of unit tests for that, but I quickly got bored, so I turned myself to production grammars which are much more fun. The grammar for this collection can be summarized as follows (see the stack example):
-- dg is a IDataGenerator
add := Add(dg)
remove := Remove(dg)
contains := Contains(dg)
guardedRemove := guard(InvalidOperatoinException, remove)
empty := add,guardedRemove,contains
nonEmpty := add,remove,contains
startRule := if(collection.IsEmpty) { empty } else { nonEmpty }
MbUnit Attributes
Now that we have built a grammar we need to tell MbUnit to load the grammar it feed it with seeds: GrammarFixtureAttribute describes a production grammar fixture, GrammarAttribute describes a method that return a IGrammar instance, SeedAttribute returns an object that is feeded into the production constructor.
public class DataGeneratorCollectionGrammar : Grammar
... // rules creation etc...
public Grammar This()
return this;
public int Seed10()
return 10;
public int Seed20()
return 20;
public int Seed50()
return 50;
public int Seed200()
return 200;
Screenshot: the grammar test case + the console output
Aaron has written a "Hello World" sample using Refly.
Refly is a helper wrapper around the CodeDom namespace that makes it much less "noisy". Refly is used in the Unit Test Generator Addin. If you are using CodeDom regularly, maybe you should have a look at this.
This is a quick recap on the available features of MbUnit 2.15.1:
Fixture type define how MbUnit is going to explore a class and build the test cases.
Fixture can be organized in a number of was. Automatically, they are organized by Namespace and Authors, but you can also tag a http://blog.dotnetwiki.org/archive/2004/05/29/277.aspx, and put them into multiple categories.
Decorators are used on the "method" level to modify the behavior of a given test. Decorators can be chained to combine their effect.
Assertion classes
Aside from the classic Assert class, there are a number of specialized assertion classes:
I'm preparing a little Reflector Addin to be able to load and execute MbUnit fixtures inside Reflector. Since the fixture tree contains all the functionalities, it was just a matter of injecting it into Reflector.
The source code is so short that I'm also publishing (note that I'm using the helper classes described here)
using System;
using System.Windows.Forms;
using Reflector.CodeModel;
using MbUnit.Forms;
namespace Reflector.Graph.Faulty
// Reflector package
public class MbUnitPackage : BasePackage
private MbUnitWindow MbUnit=new MbUnitWindow();
// Tree View
public class MbUnitWindow : ReflectorTreeView
private ReflectorServices services =null;
public MbUnitWindow()
this.Dock =DockStyle.Fill;
// needed to get reflector current element
public ReflectorServices Services
return this.services;
if (this.services!=null)
this.services.AssemblyBrowser.ActiveItemChanged-=new EventHandler(this.activeItem_Changed);
if (this.services!=null)
this.services.AssemblyBrowser.ActiveItemChanged+=new EventHandler(this.activeItem_Changed);
private void activeItem_Changed(Object sender, EventArgs args)
IAssembly assembly = this.Services.ActiveAssembly;
if (assembly!=null)
// populate tree with current assembly
public void Translate()
IAssembly assembly =this.Services.ActiveAssembly;
if (assembly==null)
MbUnit 220.127.116.11 Beta is ready for download. See latest release page on this blog for the download links
Issues, feature requests, and other bugs: please do not post them on the blog. You have two options (please it's easier to track things)
We have a menu!
This is a preview of a new Addin in the next Reflector.Graph release: Type Tree Map.
A TreeMap is special 2D visualzation of a tree. Since, Reflector provides a tree (Assembly -> Module -> Namespace -> Type -> Members), I wondered if it was possible to visualize with a TreeMap. In .Net, there are 2 controls available that can render treemaps:
I decided to use the later for creating the addin.
Note (1): The nodes represent each part of the type tree from assembly to the class members. Each node is clickable and brings the tree focus to the clicked element.Note (2): Look at the treemap, and image the nodes are you Namespace/TestFixture/TestCase hierachy. Failed test in red, successfull test in green. Just imagine, that would be the ultimate progress bar for MbUnit!Note (3): Thanks to Jamie (NUnitAddin) for the idea sharing on this.
Jamie Cansdale, NUnitAddIn man, pointed out to me that I was cited (very briefly) on .Net rocks. Here's the summary
John and Barry talk with us about Test-Driven Development, Unit Testing, and other aspects of Extreme Programming that are being used today. We had given lip service to unit testing in past shows, but John and Barry were able to explain the benefits as well as the how-to of test-driven development
http://www.franklins.net/dotnetrocks/, number 67, at 1:27 or so. This deserves a couple beers for me.
This entry is a little tutorial on how to write your own Reflector Addin. For the past weeks, I have been playing a lot with those and Lutz Roeder was backing me up on MSN for quick questions, so it's my time to return him the favor and write a tutorial about it. So let's get started.A Reflector Addin is basically only a control that gets notified when the browser changes of active items. Of course, the tricky part is to "inject" your Addin into Reflector and to "clean" up when it is unloaded. Once, you're addin is injected, the control you provided takes care of the rest. I will not focus on writing controls here but rather on the procedure to load and unload packages.
Reflector API is rather big, so this tutorial is just the "immerged" part of the iceberg.
Quick Semantics
In Reflector, an Addin is called a Package (IPackage interface). Each package can add multiple Windows (IWindow), which are the control appearing on the right, can add CommandBar items (ICommandBarItem, ICommandBarButton) to the context menus, and attach listeners to the event trigerred when the AssemblyBrowser changes of ActiveItem (IAssemblyBrowser.ActiveItemChanged). The ActiveItem is the item selected in the reflection tree.
Building a simple package (hard way)
The IPackage interface is defined as follows:
public interface IPackage
void Load(IServiceProvider serviceProvider);
void Unload();
As may already know, the Reflector API is exposed through a set of interfaces. The actual implementations are obfuscated. The IServiceProvider instance is a "facade" against the implementations and can be used to retreive IAssemblyBrowser instance (and others).
The Load method is where you will inject your Addin, while the Unload method is for cleaning. Implementing IPackage is rather boring and bug prone because you need to track all the window, menu item, etc.. that you inject to later remove them. Forgetting to remove a menu item is likely to happen often if you are in a rush. Moreover, using the serviceProvider is verbose in the sense that you access elements through a dictionary:
IAssemblyBrowser ab = (IAssemblyBrowser)serviceProvider.GetService(typeof(IAssemblyBrowser));
Let's implement a small package that displays a text box for assemblies. As mentionned above the steps are:
The control: this control display the name of the assembly, otherwise nothing.
public class AssemblyNameWindow : TextBox
private IAssemblyBrowser assemblyBrowser=null;
public AssemblyNameWindow()
this.Dock = DockStyle.Fill;
public IAssemblyBrowser AssemblyBrowser
return this.assemblyBrowser;
if (this.assemblyBrowser!=null)
this.assemblyBrowser.ActiveItemChanged -= new EventHandler(activeItemChanged);
this.assemblyBrowser = value;
if (this.assemblyBrowser!=null)
this.assemblyBrowser.ActiveItemChanged += new EventHandler(activeItemChanged);
private void activeItemChanged(Object sender, EventArgs args)
// testing if current item is an assembly
IAssembly assembly = this.assemblyBrowser.ActiveItem as IAssembly;
if (assembly!=null)
And now the package, which creates a window, and some menu items:
public class AssemblyNamePackage : IPackage
private IWindowManager windowManager=null;
private ICommandBar assemblyMenu=null;
private ICommandBarButton button=null;
public void Load(IServiceProvider serviceProvider)
IAssemblyBrowser assemblyBrowser = (IAssemblyBrowser)serviceProvider.GetService(typeof(IAssemblyBrowser ));
// create window
AssemblyNameWindow anw = new AssemblyNameWindow();
// inject window into reflector
this.windowManager.Windows.Add("AssemblyName",anw,"Assembly Name");
// create menu item and attach handler
ICommandBarManager cbm = (ICommandBarManager)serviceProvider.GetService(typeof(ICommandBarManager));
// get assembly context menu
this.assemblyMenu = cbm.CommandBars["Browser.Assembly"];
// add button
this.button = this.assemblyMenu.Items.AddButton("Assembly name",new EventHandler(button_Click));
public void Unload()
// remove window
// remove button
private void button_Click(Object sender, EventArgs args)
That's it. You have built your first Reflector Addin:
Now this is a lot of code to get thigs up and moreover, it is quite errorprone, so let's us another easier method.
Building a simple package (easier way)
This solution uses a few classes that I have written in order to handle all the "load/unload" code. The new way is mainly based on custom attributes. [Update:]Firstly, you need to make your controls implement IServiceComponent where you can register to Reflector events:
public class AssemblyNameWindow : UserControl, IServiceComponent
private ReflectorServices services = null;
public ReflectorServices Services
get { return this.services;}
if (this.services!=null)
{ ... (detach events)}
this.services = value;
if (this.services!=null)
{ ... (attach events)}
For example, the AssemblyPackage is rewritten as follows:
public class AssemblyPackage2 : BasePackage
[ReflectorWindow(Caption="Assembly Name II")]
private AssemblyNameWindow assemblyName = new AssemblyNameWindow();
[Updated: no need to implement a property]
[Updated: no need to implement Load anymore]
This looks much nicer. BasePackage will self inspect and load all properties tag will ReflectorWindow attribute. For each one of those, it will add a menu entry to the corresponding menu using the information in ReflectorCommandBar attribute. A property can have multiple command bar targets and a package can have multiple windows. The example above gives as expected a new menu item:
Where's that package ?
The helper classes are not part of Reflector but you can get them from the MbUnit CVS (look in Samples/Reflector.Graph direcotry).
This release was sick so I removed from the server...
There is a new release of MbUnit available for download at tigris. The main change in this release is the support for separate AppDomain (which was really painfull to get).
New Features:
In a previous post, I showed how you could use the IL graph to do static fault detection (at least for simple but recurrent faults). Since the code was using Reflector API, but it was more the job for FxCop rules. I started to port the code to FxCop.
As you can see on the screenshot below it is working, at least on my simple examples. In fact, it seems that FxCop decompiler is still a little buggy because it returns erroneous target offset for brtrue.s or brfalse.s IL instruction. Therefore, you will have to wait to play with this new toy :)
The figure below shows the FxCop rule applied to the test class showed in the previous post. As expected, ArgumentNotChecked fails, but the 2 others succeed the tests.
New features:
Warning: This release has been compiled agains .NET v1.1 (because System.Drawing is buggy in v1.0), therefore you must create a Reflector.exe.config file in the directory of Reflector and add the following:
About bug reports:
Please, DO NOT post bugs in the blog. It is much more easy for me to monitor bugs through the http://mbunit.tigris.org issue tracking system. :)
Download Now on www.dotnetwiki.org
I've been reading lately about PreFast, a tool for detecting fault in applications based on static analyis. Sadly, PreFact is for C++, so I wondered: can we do the same in C# ?
The test fault:
So I started with simple fault: a method that uses nullable argument and that does not check for nullity -> the NullReferenceException fault (NRE). Here are three method that illustrate the problem:
public class MyClass
public void ArgumentNotChecked(Object arg)
string s=arg.ToString(); // if arg is null, NRE
public void ArgumentChecked(Object arg)
if (arg==null)
throw new ArgumentNullException("arg");
string s=arg.ToString(); // ok, we know arg is not null
public void ArgumentGuarded(Object arg)
if (arg!=null)
string s=arg.ToString(); // ok, we know arg is not null
Sketch of the solution
The solution (I found) to this problem can be understood as taking all the possible path in the IL graph, while keeping track of the current state of the argument: Null, NonNull or Uncertain. When starting, the argument is uncertain, it could be null or not. If a method instance of the argument is called 3 things can happen:
In terms of graph theory (and QuickGraph), we need to apply the EdgeDepthFirstSearch algorithm using a visitior (IEdgeColorizerVisitor) that the job described above. More that words, let's explain this on schemas.
Checking the ArgumentNotChecked method
This methods is very simply. In IL, it looks like this:
call Object.ToString()
The corresponding graph is the following (ColorCode: Orange=Uncertain, Red=Null, Green=NonNull)
The EdgeDepthFirstSearch has only one step: it explorezs the ldarg.1 -> ToString() edge. Since the ldarg.1 status when calling ToString is Uncertain, it should output a warning. So in Reflector I get:
Checking the ArgumentChecked method
This method is already a bit more complicated since there is a branch. The IL is:
L_0000: ldarg.1
L_0001: brtrue.s L_000e
L_0003: ldstr "arg"
L_0008: newobj instance void [mscorlib]System.ArgumentNullException::.ctor(string)
L_000d: throw
L_000e: ldarg.1
L_000f: callvirt instance string object::ToString()
L_0014: stloc.0
L_0015: ret
and the IL graph looks like this:
The EdgeDepthFirstSearchAlgorithm starts by examining the ldargs.1 -> brtrue.s edge.
If we find a brtrue.s, we can easily check if it is applied to ldarg1. If yes, then we should update the argument state in the child edges. The "then" branch will be tagged Null, the "else" branch will be tagged NonNull as depicted in the figure below:
Now, when we encounter the ToString() call on the argument, it's state is set to NonNull, so that's ok.
Now, in Reflector, the fault analysis on the method should not find any warnings:
It worked!
Fault analysis can be seen as a natural application of graph theory and QuickGraph is a good for doing this. Although Reflector is a great tool, I think fault detection needs to be implemented as FxCop rules.... so stay tuned for new adventures.
TypeGraph Addin:
This is the first preview of the next killer Reflector addin: Type Graph. The addin visualizes the type inherance thourgh a graph. If a namespace or a type is selected in the Reflector tree, the corresponding graph nodes are highlighted in green.
Why such an add-in ?
Besides outputing nice graphics, Type Graph has real software analysis potential (to my point of view). For example, it can be used to visualize Code Coverage: each day, your automated test automaton creates a big poster of the application, gray nodes are not covered, red have failed some tests and green are ok. You could even make a movie and play smart at the next TechEd :) And that's just the beginning...
Thanks to Jamie (NUnitAddin) suggested me the coverage application
mscorlib graph with System.Reflection namespace highlighted
The algorithm are based on force directed layout which I found in Maxime Melchior final work (one of our student).
This is a new add-in related to the ILGraph addin for Reflector. Basically I use the IL graph to extract all the path to cover the entire graph (and get full coverage). Each path then generates an empty Unit Test Case (using Refly) that the user will have to write. Better than words, the schema below is straightforward:
The addin can generate Unit Test cases for methods, types, namespaces or even full assemblies! Since it is based on CodeDom, it supports output to any .NET language.
The output
For those who want to play with a preliminary version of the PGF, here it goes:
Download PGF v1.0 (beta)
Update: the PGF is now part of TestFu.
Yesterday, I started reading Using Production Grammar for Software Testing (UPGS) for Emin Sirer and N. Bershad (found on ModelBasedTesting site), the authors describes a method for generating test automaton based on "inversed" grammars. Following their ideas, I have designed a little framework, the Production Grammar Framework for .NET (PGF).
Yesterday, I started reading Using Production Grammar for Software Testing (UPGS) for Emin Sirer and N. Bershad (found on ModelBasedTesting site), the authors describes a method for generating test automaton based on "inversed" grammars. Following their ideas, I have designed a little framework, the Production Grammar Framework for .NET (PGF).
In this blog, I will present a framework for defining and executing production grammars. The production grammars described in UPGS are very similar to classic "LALR" grammars, in terms of understanding and semantics. The difference is that production grammars reversed the work of grammar, since they are used to produce output instead of analyse input.
Production grammars can do anything, ranging form generating data, piloting your application and generating test case, ... Since we are looking at testing applications, here are a few application that we will be interrested on:
Oracle problem
"Production grammars are well-suited for test generation not only because they can create diverse test cases effectively, but also because they can provide guidance on how the test cases they generate ought to behave. It is often hard to determine the correct system behavior for automatically generated test cases -- a fundamental difficulty known as the oracle problem. In the worst case, automated test generation may require reverse engineering and manual examination to determine the expected behavior of the system on the given test input." The authors propose two ways of dealing with the oracle problem:
Since the PGF is based .NET code, you can theoretically add any verification code and if available, compare with any other implementation. This will be illustrated in the example
What is a Production Grammar:
"A production grammar is a collection of non-terminal rules to terminal rules that resembles a regular parsing grammar, but is used "in reverse." That is, instead of parsing a sequence of tokens into higher level constructs, a production grammar generates a stream of tokens from a set of non-terminals that specify the overall structure of the stream".
Let's see that on a simple example. Consider the following comma separated list of names:
An valid EBNF grammar to parse this stream would be ([A-Z] designs capital letters, [a-z] lower case letters, + one or more occurence, * zero or more occurence):
name := [A-Z] [a-z]+
names := name (',' name)*
In the case of production grammar, we want to create that list of name. In C#, a possible implementation of the production grammar would be as follows:
public class NamesGrammar
public string Name()
int count = nextRandom(); // gets a random int
return getUpper() + getLowerString(count); // getUpper return upper case, getLowerString returns lower cased string
public string Names()
int count = nextRandom();
string names = Name();
for(int i=0;i!=count;++i)
names += ',' + Name();
return names;
The example will generate a list name when the Names method is called, we have production :). This is just a dummy example, it is 100% hard-coded and very difficult to maintain.
Production Grammar Framework
Before starting to work on an example (guess which), let us define important notations/interfaces of the PGF:
Those 5 interfaces form the kernel of the PGF, the rest of the framework is built on top and around them to help the user implement grammars.
The working example: a Stack
In order to crystilase the ideas presented here, we will consider the problem of testing a Stack (as in Test Driven Developement in .NET). A simple unbounded stack can be formalized by the following interface:
public interface IStack
void Push(Object);
Object Pop();
Object Peek(); // equivalent to Pop() in TDD
bool IsEmpty {get;}
The grammar
Before writing down the grammar in C#, it is useful to formalize it in a "pseudo" EBNF-like notation. In this example, there are 3 terminals: Push, Pop, Peek (we omit IsEmpty for now):
push := stack.Push(...)
pop := stack.Pop()
peek := stack.Peek()
Since Pop and Peek can throw if the stack is empty, we create a special non-terminal rule that guards production agains a specific exception type. This gives us the 2 following non-terminal rules:
gardedPop := gard( pop, InvalidOperationException )
gardedPeek := gard( peek, InvalidOperationException )
Of course, we need to be able to decided wheter we want to execute the guarded rule or the non guarded. Again, we define a new non-terminal rule that works as a "if-then-else". This gives us 1 more non-terminal rule:
nonEmpty := push | pop | peek
empty := push | gardedPop | guardedPeek
stackRule := if(isEmpty) { empty } else { nonEmpty }
The final step is to decide how many execution we want. Since we can break the production at the IProduction level, we go for infinite:
stackGrammar := stackRule*
The full grammar can be summarized as
push := stack.Push(...)
pop := stack.Pop()
peek := stack.Peek()
gardedPop := gard( pop, InvalidOperationException )
gardedPeek := gard( peek, InvalidOperationException )
nonEmpty := push | pop | peek
empty := push | gardedPop | guardedPeek
stackRule := if(isEmpty) { empty } else { nonEmpty }
stackGrammar := stackRule*
At this point, we have define a grammar for piloting the stack written in a "pseudo"-EBNF language. The simplicity of the notation let us concentrate on the problem and not on the tool to solve it. However, as it is, the grammar is pretty much useless, since it is missing verification code. We will see that the verification code can be easily added while writing the grammar in C#.
Rewriting the grammar in C# with PGF
The PGF contains a bunch of built-in non-terminal rules and helpers that will help you translate a grammar into functional C# code. In this example, we will encapsulate the grammar in a StackFixture class that contains a stack field:
public class StackFixture
private Stack stack = new Stack();
Step 1: Creating the terminal methods
Following the way we constructed the grammar, we begin by defining the terminals. The easiests solution is to define one method for each terminal and then wrap it into a IRule. For example, the push terminal is implemented as follows:
public class StackFixture
private Stack stack = new Stack();
private IRule push;
public void Push()
public void CreateGrammar()
this.push = Rules.Method(new DefaultMethodDelegate(this.Push));
We have added 3 things: a IRule field member to store the "push" terminal, a Push method that actually pushes something on the tested stack and a CreateRules method that will be used to creates the grammar. The Rules.Method is a static helper class that encapsulate the call to a member method into a rule. The same operation can be repeated for pop and peek.
Step 2: Adding code for the Oracle problem
In order to be able to verify assertion on the fixture, we need to solve the Oracle problem. For this specifiy case, we can do the Comparaison testing approach where we execute the operations on another implementation and verify that outputs are different (NC, not NSC).
public class StackFixture
private ArrayList list = new ArrayList();
private Stack stack = new Stack();
private IRule push;
public void Push()
Assert.AreEqual(list.Count==0, stack.IsEmpty);
Assert.AreEqual(list[list.Count-1], stack.Peek());
Step 3: Creating the non-terminal rules
From this step, the PGF provides the "classic" non-terminal rules and helper classes to create them (Rules) that makes the rest of the implementation straightforward:
public class StackFixture
IRule push, pop, peek;
IRule guardedPop, guardedPeek;
IRule empty, nonEmpty;
IRule stackRule;
IRule stackGrammar;
// returns true if stack is empty
public bool IsEmpty()
return this.stack.IsEmpty;
public void CreateGrammar()
push = Rules.Method(new DefaultMethodDelegate(Push));
pop = Rules.Method(new DefaultMethodDelegate(Pop));
peek = Rules.Method(new DefaultMethodDelegate(Peek));
guardedPop = Rules.Guard( pop, typeof(InvalidOperationException) ); // gard( pop, InvalidOperationException)
guardedPeek = Rules.Guard( peek, typeof(InvalidOperationException) );// gard( pop, InvalidOperationException)
nonEmpty = Rules.Alt( push, pop, peek); // push | pop | peek
empty = Rules.Alt( push, guardedPop, guardedPeek);
stackRule = Rules.If(new ConditionDelegate(IsEmpty), empty, nonEmpty); // if(IsEmtpy) empty else nonEmpty
stackGrammar = Rules.Kleene(stackRule); // stackRule*
Step 4: Creating a grammar and executing a production
In order to simplify our lives, we make StackFixture inherit from the Grammar class (which implement IGrammar) provided by the PGF. This class takes care of setting up the production factory and launching productions. Of course, this part of the framework can be easily customized and extended to plugin into your existing test automaton (MbUnit, NUnit, csUnit, ...).
public class StackFixture : Grammar
public StackFixture()
public void CreateRules()
// required for Grammar
this.StartRule = this.stackGrammar;
A production can then be executed by launching the Produce method:
StackFixture fixture =new StackFixture();
Production Grammar Framework is an effective tool to create and implement production grammar. Production grammar are used to model the complex behavior of application and automate the creation of complex test case. In fact, you could easily reuse your existing Unit Test cases with a production grammar! Of course, PGF will be part of MbUnit in the next release. Moreover, since the "hard" work is done by the machine, you can expect to get much better code coverage using Production Grammar (or MBT) than with classical unit tesing.
Future directions and the quizz
This post is already long so I will stop here. However, you can start to think about other interresting use of this technique:
The quizz question: How does this relates to model based testing ?
With the growing need for a decent .NET wrapper of LAPACK and since there exists no free wrapper around it (commercial version here), I have decided to take a try at this adventure (working with managed C++ is always an adventure). To help me in the task, Lapack++ a C++ wrapper around LAPACK: simple and very well done, should speed up things... (to be continued)
Reflector.Graph is a Reflector 18.104.22.168 Add-in. (it is my new toy project). Actually, it contains 3 graph-based package for Reflector (more will come )
Don't forget to drop a line to tell me about the tool.
Go to Reflector.Graph v1.1
Hint: Click and move to zoom in/out of the graphsHint2: Make sure you download Reflector 188.8.131.52Hint3: Load Reflector.Graph.dll assembly in the Addin dialog.
After a number of requests, QuickGraph assemblies have been merged. Here is the new layout:
This is a new experimental Reflector Add-In that will be part of the upcoming Reflector.Graph addin (see Assembly Grapher and Il Grapher). The objective of this addin is to rank methods using a method similar to google.
The graph
Consider a graph where the vertices are the methods of the classes, and each edge represents the fact that the source method calls the target method. For example, take the following dummy class:
public class Test
public void Hello()
public void HelloWorld()
The method graph from this class will contain
PageRank, The Algorithm
PageRank, which is the algorithm that Google uses to rank pages, is a well known and easy to implement algorithm (it is implemented in QuickGraph). The idea behing is very simple and elegant: important pages are reference by other important pages. So basically, PageRank algorithms can help you order the vertices of your graph by order of importance.
PageRank and MethodRank
Contrary to Google, where the vertices are pages and edges are the hyperlinks, the vertices are methods. However, the PageRank idea translates naturally to the method graph: important methods are called by other important methods. Why would we need to know which are the important vertices ? Here are my intuition (not tested) about this:
The AddIn
for the pleasure of the eyes
This post is just a small remainder of the meta-physical questions I'm asking myself, specially because testing is basically trying to solve an unsolvable problem (Halting theorem)
I have attended yesterday to a presentation about SharePoint by Patrick Tissegem and Inge De Neef (?could not find her blog?). Inge, sorry for the question :). Patrick was presenting through a VPN and doing live stuff on this SharePoint site (Inge also did live manipuation). It did not crash, amazing. This was my first contact with SharePoint and it looked like a terrific product for creating intranet, but it also appeared to me that it could quickly become a mess if you start tweaking it!
I also met a lot of fellow belgian bloggers. Since I'm not good with names, I must have forgotten many but here are the people I saw and spoke to: Jan Tiellens, Tom Mertens (MSDN content manager I think), Thomas Delrue (who will be doing an internship at Microsft as SDE/T this summer), and I forgot the other... Make yourself heard :)
There was also a surprise from the MSDN team before the presentation where Tom said:
"We have two .Net gurus in the room[...] I would like you to give a warm applause to Jonathan de Halleux and Thomas Delrue[...]".
I must say I was not easy with that, but he then said:
"Microsoft has a gift for both of them[...] bottles of champagne[...]"
Then I was much more relax :) :) :)
That's another graph-based Reflector Add-In. It creates and displays the dependency graph between the assemblies that are loaded in Reflector.
ps: Thanks to Lutz who wrote the AssemblyGrapher application to make it a Reflector add-in.
I have received an interresting post from Kent Boogaart on the CodeProject article that pointed out a major limitation of Composite Unit Testing:
I'm a little unsure how this tests all an interface's members. Take ICollection, for example. Your CollectionTest implementation would receive an instance of ICollection manufactured via an appropriate factory.Say you wanted to test that ICollection.Count was returning the correct value. How would you test this without knowledge of the factory method called?Thanks,Kent
I'm a little unsure how this tests all an interface's members. Take ICollection, for example. Your CollectionTest implementation would receive an instance of ICollection manufactured via an appropriate factory.Say you wanted to test that ICollection.Count was returning the correct value. How would you test this without knowledge of the factory method called?Thanks,Kent
There he has a point. You cannot test ICollection.Count using Composite Unit Testing as it is now. You could test it through the IList test interface, but that's not the point.
A way of overcoming the limitation would be the ability for the user to give a "gold" instance along with the test instance. The gold instance would be mock of the interface as it "should" be and could be used to do the ICollection.Count test. For each factory method, the framework would look for it's mock counter part, if found, it is feeded to the test method. Let's illustrate that on ICollection:
The gold instance class (mock):
// the mock
public class CollectionMock : ICollection
private int count=0;
public int Count
get{ return count;}
public class ArrayListFactory
// provider for empty arraylist
[Factory] // new attribute, tells the framework it is a factory method
public ArrayList Empty
return new ArrayList();
[MockFactory] // tells the framework it is a mock method
public MockCollection EmptyMock // name is important must be "Method"+Mock
MockCollection col = new MockCollection();
return col;
// 1 provider + mock
public ArrayList One
return Empty.Add(null);
public MockCollection OneMock // name is important must be "Method"+Mock
MockCollection col = new MockCollection();
return col;
public class CollectionTest
public void CountTest(ICollection tested, ICollection mock)
I have been facing a silly bug related to AppDomain, so stupid that it is worth mentionned in a blog.
The symptoms
Load an assembly in a separate AppDomain, create an instance of a type. Things work correctly. Then unload the domain, and recreate the type. Somehow, strange bugs (Custom Attributes not detected, the debugger messed up) arise.
How-to recreate it:
Assume that we have the Assembly MbUnit.Core.dll, MbUnit.Framework.dll (that references Core) and Test.dll that references both. Core defines an abstract Custom Attribute TestPatternFixtureAttribute,
public abstract TestFixturePatternAttribute :Attribute{...}
public class TestFixtureAttribute : TestFixturePatternAttribute{...}
public class MyTest{...}
The fix
In point 2,5, I have been using AppDomain.CreateInstanceFromAndUnWrap, this is the error. I should have been using AppDomain.CreateInstanceAndUnWrap. The difference is subtle, 4 letters.
The explanation
I'm still unsure of the explanation.... so I'm waiting for someone to come up with a relevant explanation :)
Page rendered at Friday, May 22, 2015 10:45:17 PM (Pacific Daylight Time, UTC-07:00)
The opinions expressed herein are my own personal opinions and do not represent
my employer's view in anyway.


text:
Image by National Portrait Society Collection
The Good-morrow
John Donne, read by Adam Foulds
The Good-morrow
John Donne, read by Adam Foulds
Jump to navigation
Your basket is empty.
No recently played poems.
Image by National Portrait Society Collection
John Donne, read by Adam Foulds
John Donne, read by Adam Foulds
John Donne was the greatest non-dramatic poet of his time, and its most admired preacher. He was...
I wonder, by my troth, what thou and I
Did, till we loved? Were we not weaned till then?
But sucked on country pleasures, childishly?
Or snorted we in the Seven Sleepers' den?
'Twas so; but this, all pleasures fancies be.
If ever any beauty I did see,
Which I desired, and got, 'twas but a dream of thee.
And now good-morrow to our waking souls,
Which watch not one another out of fear;
For love, all love of other sights controls,
And makes one little room an everywhere.
Let sea-discoverers to new worlds have gone,
Let maps to other, worlds on worlds have shown,
Let us possess one world, each hath one, and is one.
My face in thine eye, thine in mine appears,
And true plain hearts do in the faces rest;
Where can we find two better hemispheres,
Without sharp north, without declining west?
Whatever dies, was not mixed equally;
If our two loves be one, or, thou and I
Love so alike, that none do slacken, none can die.

subset: commoncrawl


text:
The process is to be completed by September 2013
With the number of applicants seeking government jobs increasing steeply in the wake of global recession and revised pay structure, the Staff Selection Commission is gearing up to recruit one lakh aspirants for non-gazetted and non-technical posts in Central government during 2013-14.
Disclosing this to reporters here on Thursday, SSC Chairman N.K. Raghupathy said the organisations/ departments for the proposed recruitment include Food Corporation of India, Prasar Bharathi, Cabinet Secretariat and eight Central Armed Police Forces (CAPF), including CRPF, ITBP, BSF and CISF. The entire process of recruiting one lakh candidates would be completed by September, 2013.
10 lakh aspirants
He said that while the applicants were over 10 lakh in 2008-09, their number touched 86.5 lakh in 2011-12 for 84,500 posts. Already 90,000 aspirants had applied for 63,000 jobs this year so far.
Mr. Raghupathy said that 22,000 posts of the proposed one lakh would be in Andhra Pradesh, including 13,000 in eight CAPF. Apart from this, another 10,000 constables' posts in CAPF in Andhra Pradesh would be filled up this year. They include a backlog of 7, 460 posts which could not be filled up last year.
Mr. Raghupathy said that in the 11 left-wing extremism affected districts in the States, the posts were reserved only for local candidates and aspirants from other districts could not apply in those places. However, aspirants from left-wing extremism affected districts could apply anywhere in the State.
IG, CRPF (South) I.N.R. Reddy said the Ministry of Home Affairs had permitted the CAPF to directly recruit for filling up the backlog posts.
The CRPF personnel would conduct rallies in January and February in the villages of the 11 districts to promote awareness about jobs in
CAPF and recruit local youth. They would also visit schools and distribute pamphlets.
22,000 posts of the proposed one lakh will be in A.P., including 13,000 in eight CAPF In extremism-affected districts in the States, the posts are reserved for local candidates
22,000 posts of the proposed one lakh will be in A.P., including 13,000 in eight CAPF
In extremism-affected districts in the States, the posts are reserved for local candidates


text:
I wanted to take a moment to address the ice bucket challenge that is all the rage on the Internet. I may seem like a bit of a downer but I have my reasons for not doing it and I wanted to address them. 592 more words
Tags » Lou Gerhig
ALS Ice Bucket Challenge
Recently there has been a lot of debate on the effectiveness and validity of the Ice Bucket Challenge.
For any of you who may have (somehow) not heard of this movement by now, here's a little Q&A: 1,157 more words
Ice Buckets and Stuff
So the other day I was nominated for the ALS Ice Bucket Challenge and did it but the entire time this has been going on I've seen person after person (including little kids) dumping ice on themselves and I couldn't help but wonder if they really knew what was going on. 634 more words
Baseball And The Saturday Evening Post April 17, 1926
"Boy's Baseball Team" by Eugene Iverd April 17, 1926
Eugene Iverd is a pseudonym for George Ericson. He was born in St. Paul Minnesota in January of 1893. 300 more words


text:
2012 Advent Devotions
500 - 1,000 downloadsAdd this app to your listsTweets por @Appszoom
Daily Christian devotions for the advent season. Devotions are written by faculty, administrators, and students associated with the Mennonite Brethren Seminary at Fresno Pacific University (http://seminary.fresno.edu). Web and print versions are available at http://www.fresno.edu/adventdevotions.
Tags: advent devotions, advent devotional script.
Tags: advent devotions, advent devotional script.
Comments and ratings for 2012 Advent Devotions
- There aren't any comments yet, be the first to comment!


text:
Famous quotes by Edmund S. Morgan:Sort:PopularA - Z
Share your thoughts on Edmund S. Morgan's quotes with the community:
Quote of the Day
Would you like us to send you a FREE inspiring quote delivered to your inbox daily?
Use the citation below to add this author page to your bibliography:
"Edmund S. Morgan Quotes." Quotes.net. STANDS4 LLC, 2015. Web. 26 May 2015. <http://www.quotes.net/authors/Edmund S. Morgan>.


text:
A division of Faegre Baker Daniels, FaegreBD Consulting is a national advisory and advocacy firm focusing on growth sectors of the U.S. economy.
FaegreBD Consulting
The Department of Energy gives recommendations for upgrading the country's energy infrastructure in its recently released QER report.
A Vision to Re-Energize America
A new associate in Indianapolis brings a big tax background to FaegreBD's corporate team.
Don't Forget to Add the Tax
Ranked 32nd on Law 360's 2015 list of the 100 best U.S. law firms for women, FaegreBD is committed to advancing women in the legal industry.
FaegreBD Tops the Charts in 2015
Join us for our 2015 M&A Conference in Indianapolis. Share knowledge and get great insights about complex M&A topics and market updates.
Let's Make A Deal: 2015 M&A Conference
Make sure your employees stay legal overseas with these five things you need to know about international movement.
Locked Up (or Kicked Out) Abroad
Meet Stephen Kubiatowski. A new partner in our Washington, D.C. office, Steve brings more than two decades of trial experience to the table.
Meet Stephen Kubiatowski
Representative and warranty insurance continues to gain momentum. Get negotiation tips and market trends to keep you in the loop.
Rep & Warranty Negotiation Know-How
Faegre Baker Daniels is a full service law firm providing business solutions to local, national and international organizations. We serve our clients with the highest levels of professionalism, skill and integrity. Our 750 corporate, litigation and regulatory professionals collaborate across our 13 locations in the United States, U.K. and China to deliver practical solutions for our clients' business needs.
*Your message has been successfully sent.
In considering prior results, please be aware that: (i) each legal matter is
unique; (ii) prior results are not necessarily representative of all our
matters; and (iii) you should not rely on prior results to predict future
success in similar matters.
Copyright © 2000-2015 Faegre Baker Daniels LLP.
All Rights Reserved. | Disclaimer
Notes: Please do not send confidential information or
sensitive materials through this form.
Transmission of information to us via this feature does not establish an attorney-client relationship. Do not send any information that you would have treated confidentially.


text:
|Property type
|Minimum Stay
|2 - 3 nights
Just steps from the lake, with sandy bottom swimming, boating, skiing, boarding, tubing, kayaking, jet skiing, or water Volleyball on the sandbar. This sweet 1930's bungalow/cottage with French doors leading to front porch, is situated on a private lot with room to 'Play'.
Sip your coffee on the front enclosed nautical themed porch, and watch the sun dance on the water with your view of the lake. Walk across the street and take a morning dip in the clean waters of Big Green Lake. Great for kids, as it is a sand bar and there is lots of space to play in the soft sandy bottom shallows.
Launch your boat and anchor it within view at the lake access. Grab your cooler and off you go for your cruise around the lake.
Take a stroll to Reilly's Pub, less than 2 blocks from the bungalow, and enjoy a scrumptious meal on their outdoor patio. Or fire up the Weber and enjoy dinner, with outdoor dining. After dinner, relax in the Adirondack chairs by the fire pit, roasting s'more. What an Escape!
Description-- Lake Shore Bungalow: Accommodations:
Bedroom 1 - Master Bedroom - main floor: Queen bed, 1.5 closets and Storage shelves.
Bedroom 2 - Guest Bedroom - upper level: Two XL-Twin beds, with dormer & 2 windows.
Bedroom 3 - Guest Bedroom - upper level: One XL-Twin bed, with dormer & 2 windows.
Additional: Sofa for one individual (not a sofa/sleeper), in living room.
Additional: Convertible sofa for one individual, on 3 season porch.
Front Porch, enclosed, picture window views of lake.
French doors separate porch from main living area, which has vintage pottery barn style decor. Open layout to kitchen and dinette area. Newly remodeled bath and kitchen.
Full Bath on main floor, with tub/shower combined, pedestal sink and vintage chrome fixtures.
All linens provided: Sheets, blankets, bath towels, kitchen towels, beach towels. Leave your linens at home. We do the laundry after you leave.
-Sandy bottom Swimming - lake access across the street.
-View of the lake, Fire Pit, with Adirondack chairs and additional canvas bag chairs are available for additional seating.
-Outdoors Grilling & dining, Yard with Room to play.
-Croquet set, board games and puzzles for a rainy day.
-Cable TV/DVD and Wi-Fi for our guests.
-IPod/IPhone alarm clock/charger in Master Bedroom.
-Off street parking for two vehicles in private driveway.
-Kitchen equipped with: Pots/pans, dishes, glasses, silverware, coffee mugs, baking needs, spices, salt/pepper, sugar, dish soap, gas stove/oven, refrigerator, coffee pot, toaster, blender, microwave, PUR water filter.
-Laundry: Washer, & Dryer on premise. Outdoor clothesline for wet swim gear.
-Air Conditioning: Two units built-in, one upper and one lower. Stays nice in cool.
-Central heat for cool Spring/Fall nights.
Six sister's looking for a cozy cottage near a lake and this cottage met our every needs and expectations. When we walked in we were in owe of how the decorating was done. It was so clean. Beds were so comfy. Kitchen was stocked with every possible necessity to enjoy meals, drinks and relaxation for our newest vacation get away. Reilly's Pub makes great drinks and excellent food. For 16 years we've gone someplace different each year but lakeshore bungalow might be the first time we would come back to enjoy again. Don't know you personally but you definitely know how to run a vacation rental business. Thanks again Faith for answering our email and getting back to us about questions we had.
Lake Shore Bungalow lived up to its description and exceeded our expectations from the moment we drove up. Everything was tidy and perfectly presented and the kitchen was stocked ideally for our needs. Just steps from the lake, we enjoyed walking, fishing, and peace. The neighborhood tavern (Reilly's) was an easy walk from the cottage & so yummy. And we loved exploring the fantastic shops in Princeton! Mostly, your hospitality was apparent in each room and we look forward to our next retreat to this easy getaway. We were blessed with this perfect unplugged family time. Thank you!
A lovely little cottage in a beautiful location.
Everything was as described on the internet, the property was clean, tidy and well maintained.
The welcome pack of pancake mix and maple syrup was much appreciated, however we had neither the time nor the eggs required to make them.
We arrived at the location earlier than predicted and the owner treated us to a drink in Reilly's pub until the property was ready for us to enter.
I would certainly recommend this cottage and this location to others, my only suggestion would be to come before the end of September as many local amenities close for winter in October, although the Atumn colours were beautiful.
Reilly's pub provided good food at a reasonable price, the beer was good as was the service. I would also reccomend Jillian's cafe in Princeton for breakfast or lunch.
E&M Sharp
Edward & Moira
My husband and I loved our stay at this comfy, cozy, quaint and FUN vacation rental. We had beautiful Fall weather during our stay so took advantage of kayaking then sitting in the Adirondack chairs stairing at the lake. We also took in a bit of the local life at Harvest Fest in Green Lake--really enjoyed it. While we ate at several local eateries, by far our favorite was the short walk to Reilly's Pub down the street from the bungalow. We highly recommend the tour of Green Lake on the Escapade--interesting history and a beautiful lake. Even if it had been bad weather and we would have been stuck inside I would have enjoyed myself as Faith's decorating flair was so appealing and we had every amenity we needed. Thank you so much!
The house was adorable, and EVERYTHING was thought of. We didn't have to bring anything other than our clothes. What a fantastic little getaway. Gathering around a roaring fire was a great way to end the chilly fall days and perusing the flea market and antique malls with friends was a nice use of Saturday afternoon. I loved watching the fog rise from the lake in the morning almost as much as my daughter loved hunting for tiny shells on the beach. We're considering another getaway next summer, if they have any openings!
We loved the Lake Shore Bungalow! Everything we needed was provided, it was like staying at a nice hotel! The cottage is very clean and comfortable, for a family of five no problem. Lake access right across the street and you can anchor your boat in between the 2 private piers. The County Park launch is just around the corner from the cottage. I would highly reccommend this place for any occasion. We will be coming back next year! Thanks Faith for being a wonderful host!
The bungalow is located on the Southwest end of Big Green Lake, near the intersection of Hwy. 73 & Co. Hwy. K.
Reilly's Pub is 1.5 blocks from Bungalow.
County park and beach is approx. 1/2 mile away.
DT Green Lake is 15 min away.
DT Princeton is 7 miles away.
Lake Shore bungalow has lake views, it is not directly on the lake, it is across from the neighborhood lake access.
Boat Lunch nearby.
Horseback Riding about 3 miles away.
Saturday Morning is the Princeton Flea Market. Princeton is also good for antiquing and shopping. Unique stores.
Friday night summer movies in the part in Green Lake. Tuesday night concerts on the square in Green Lake.
Dining in Green Lake includes: Goose Blind, Norton's supper Club, Waterfront Grill, Harbor Lights, Little Corporal, Adams Rib, Sugar Lips (great coffee too), and more.
Other Activities: Hot Air Balloons, Horseback Riding, Antiquing, shopping, dining, swimming, water sports, cycling, Opera House Events including big names, i.e. 'Second City' Comedy Performance. Art Fairs, Hiking.
Golf: Tuscumbia and Lawsonia Golf Courses
Ski: Cascade Ski Resort
|Rate Period
|Weekend Night
May 16 2015 - Sep 30 2015
3 night minimum stay
My Standard Rate
3 night minimum stay
|Refundable damage deposit
|Tax Rate
Payment is usually accepted in the quoted currency (USD) unless the currency and the amount is specifically agreed in advance with the owner / advertiser.
Learn more about this vacation rental at the owner's website:


text:
We found 4 sites within 15 miles of Ingleton with 2 bookable
Orcaber Caravan and Camping Site
Settle, North Yorkshire, England Show on map
|Non-electric grass pitch
|6 x
|From £14/€19.46/AU$26.84/$20.89/20.10Fr per 3 nights
|Electric grass touring pitch
|6 x
|From £18/€25.02/AU$34.51/$26.86/25.84Fr per night
|Electric grass tent pitch
|6 x
|From £19/€26.41/AU$36.43/$28.35/27.28Fr per 3 nights
Settle, North Yorkshire, England Show on map
|Non-electric grass tent pitch
|8 x
|From £20/€27.80/AU$38.34/$29.84/28.72Fr per night
|Hardstanding electric touring and motorhome pitch
|6 x
|From £23/€31.97/AU$44.10/$34.32/33.02Fr per night
Kirkby Lonsdale, Cumbria, England Show on map
Kendal, Cumbria, England Show on map
Let us help you find more search results…
Try increasing your search radius to within 25, 35, 45, 55 miles of Ingleton.
Try widening your geographic area to: North Yorkshire, or North East England, or England.
Remove all
or some of the search filters:
Remove Motorhome service point
Want to see more? We're only showing the sites that are bookable on Pitchup.com.
Show campsites and holiday parks that aren't bookable through Pitchup.com...


text:
Prices and availability are subject to change from the time and date that you print this page.
5/26/2015 4:11:56 AM. For Customer Service, please call 800.967.6696
Pickup Check store pickup options
The Story
Take the guesswork out of those imperfect measurement suggestions with these charming measuring spoons that dole out a smidgen, pinch and dash.
Details and Dimensions
3-Piece Smidgen Measuring Spoon Set: one each of smidgen, pinch and dash. 4"H
- 18/8 stainless steel
- Dishwasher-safe
- Made in China
DashWidth: 0.625" Depth: 0.625" Height: 4" Overall DimensionsHeight: 4" PinchWidth: 0.5" Depth: 0.312" Height: 3.9" SmidgenWidth: 0.5" Depth: 0.25" Height: 3.875"
Return/Exchange Policy
We will accept merchandise returns of non-furniture items within 90 days of customer receipt.
Outlet purchases and purchases made outside the U.S. may only be returned to the purchase location. All other Crate and Barrel non-furniture merchandise may be returned in person to any U.S. Crate and Barrel store (excluding Outlets) or by mail (if the item was ordered online or by phone and received by mail).
Bedding items can be returned or exchanged only if in their original packaging.
An appropriate exchange, credit or refund will be issued for the item(s) and any taxes due to be refunded in accordance with applicable state law.
Depending on the nature of the return/exchange and the presence of an original receipt or packing slip, we will issue an appropriate credit or refund in one of the following ways:
- With an Original Sales Receipt or Packing Slip, the item's purchase price will be refunded in the Original Form of Tender (cash refunds are limited to $100 in store with any balance refunded as a check by mail).
- With an Original Gift Receipt or Gift Packing Slip, the item's purchase price will be refunded via a Shop Card.
- Without an Original Sales Receipt, Gift Receipt or Packing Slip, the item's current retail price will be refunded via a Shop Card, regardless of amount. Valid photo ID is required for store returns without an Original Sales Receipt, Gift Receipt or Packing Slip.
Please note: Shop Cards, Gift Cards and eGift Cards are valid for Crate and Barrel, CB2 and The Land of Nod purchases and are not redeemable or subject to exchange for cash or a cash equivalent, except as required by applicable law.


text:
Family Psychological Services, LLC
- Lawrence Office2601 W 6th STE A
- Lawrence, KS 66049-4319
- Phone: 785-371-1414
Kansas City Metro Office
(Dr. Wes Only)
4200 Somerset Dr, Ste 214A
Prairie Village, KS 66208
Phone: 913-888-8967
You have a choice in mental health providers. Here are a few reasons to choose us:
- Expertise: We are renowned in Lawrence and the KC Metro for providing quality service to children, teens, families and adults within our scope of practice.
- Experience: We've worked with a wide range of clients with a host of different concerns.
- Availability:This isn't a hobby, it's a mission. We're each full time practitioners with full time case loads. It can be hard to get in to see our staff sometimes, but there's a reason for that and we're constantly expanding to provide more services.
- Diversity: Our staff is diverse in ethnicity, culture, and age and we're excited to work with an equally diverse clientele within our scope of practice.
Check back often! We have a whole new website in the works to improve navigation and smartphone integration and ease access to our extensive catalog of media resources.
Family Psychological Services is owned and operated by Wes Crenshaw, PhD. He and his three associates see a broad clientele from Lawrence and Douglas County, where we've doubled our office space to better serve our growing caseload. Dr. Wes also sees Kansas City Metro clients on Tuesdays and Thursdays at our office in Prairie Village. Kelsey Daugherty APRN sees clients in Prairie Village on Fridays. We'll soon be expanding there too!
In addition to top quality psychotherapy and assessement, we now offer state-of-the-art medication management to clients seen here for therapy, emphasizing interdisciplinary collaboration, ePrescribing, convenient client access, and empirically valid protocols.
Please hang in there. We know it's been difficult to get an appointment, but Alisha and Kelsey are going full time, we're continuing to add office space, and interviewing additional staff to meet the demand. We'll be teaching these talented new professionals what they need to know to offer the same top-quality service you've come to expect from Family Psychological Services.
We're building on Dr. Wes's 22 years of experience in business and mental health service delivery to enhance what you and your family get out of treatment, from the time you make your first call to our office, until the time we shake hands and say "good-bye."
Family Psychological Services offers a full range of services for families, children, teens, and college-aged adults and a limited scope of services for adults over age-25.
Click below to learn more:
Available in PAPERBACK, on KINDLE, in
HARDCOVER LIBRARY EDITION through Ingrams Library Services
and on audiobook from AUDIBLE.COM
Dr. Wes Crenshaw offers thirteen principles for successful living with ADD and ADHD drawn from twenty-two years of experience and 23,000 hours of clinical discussions with hundreds of interesting clients. Written in an entertaining, conversational style for readers aged 15 to 30, Dr. Wes pulls no punches in confronting the cognitive, social, emotional, and academic pitfalls people with ADD face every day. He also helps families, friends, and romantic partners understand a diagnosis of ADD not as something to fear or an excuse, but as a first step on the path to a better tomorrow.
Wes Crenshaw, PhD is a Kansas Licensed Psychologist who is Certified in Couples and Family Psychology by the American Board of Professional Psychology (ABPP) and holds a Health Certificate in Sex Therapy and Sex Education from The University Of Michigan. Dr. Wes has been a member of the Lawrence community for over 25 years, having received his PhD from the University of Kansas in 1994. He trained with some of the masters in the field, and is skilled and experienced in working with adults, teens and couples.
Dr. Wes has served Lawrence, Douglas County and the greater Kansas City metro since 1999. He is coauthor of the Double Take column published weekly since 2004 in the Lawrence Journal World. He is a frequent guest in Kansas City area media and writes for Your Teen and ADDitude Magazines.
Download Dr. Wes Crenshaw's Professional Vitae
"When people come to therapy they don't want to talk to a therapist. They want to talk to a person who knows how to do therapy. Regardless of how well you're trained or how much you know, if a therapist can't talk with kids and families like a regular person, he won't be able to communicate the important ideas of therapy. That's how I try to work with my clients -- like a real person who knows something useful that could bring about change."
--Wes Crenshaw, PhD ABPP
Kelsey Daugherty RN, MSN, APRN, PMHNP-BC can prescribe all psychopharmaceuticals including stimulants under protocol with Dr. Cris Davilla (see below). She is empaneled with BCBS of Kansas, Coventry, Aetna and Tricare and is presently awaiting additional panels.
Kelsey attended KU for two years before transferring to Avila University where she received her BSN. She began her career at the MD Anderson Cancer Center in Houston after spending a summer in Tanzania working at Bugando Medical Center. She completed practica at Awakenings KC, the KU Child and Adolescent Psychiatry Clinic, Stormont-Vail West, and St. Luke's. Kelsey received her MSN from the University of Missouri at Kansas City where she will continue her graduate program to complete the Doctorate of Nursing Practice (DNP) in 2017. She is an amazing addition to our team bringing fresh ideas and the lastest research in medication management to every case she sees. When you meet her, you won't have to ask why we jumped at the chance to bring her to Family Psychological Services.
"Good medication management begins with good communication between the client, the therapist, and the prescriber. Sometimes clients come in feeling they've been on a psychiatric conveyor belt. My goal is that everyone I work with leaves feeling they've been listened to and understood. "
--Kelsey Daughtery, APRN
Adrian Zelvy, LCPC completed an MA in Counseling Psychology-Counselor Education specializing in Couple and Family Therapy in 2007 from the University of Colorado-Denver. Prior to working as a therapist, Adrian worked with adults and children with disabilities to re-enter the competitive workforce and as a high school teacher.
Adrian has practiced in the Lawrence community since 2008. Prior to that he worked at the Wyandot Center in Kansas City Kansas as a part of Project Redirect – providing court ordered therapy services to juvenile offenders. Adrian began serving children, teens and families in Lawrence with the Bert Nash Center's Child and Family Services Team in 2008. He uses a collaborative approach that maximizes the strengths of those he works with and empowers change.
"I am not here to fix you, because I do not see you as broken. Instead, therapy is a process of identifying and initiating small shifts in our way of thinking, feeling and behaving that lead to healthier patterns of living with ourselves and others. Sometimes taking the first steps can seem difficult, but rest assured we'll take them together."
--Adrian Zelvy, LCPC
Alisha Saucedo LSCSW accepts BCBS of KS and BCBS of KC PPO, as well as United Health Care and KanCare. Call Carrie soon for an appointment as Alisha is building a full time caseload fast. She specializes in play therapy for younger children, but also has experience in acute psychiatric care, juvenile justice, and the foster care system. She sees adolescents, young adults, and families and is skilled in play therapy, behavior modification, solution focused therapy, and Nonviolent Crisis Intervention. She is certified in Eye Movement Desensitization Reprocessing (EMDR) for adults and children and works well with clients having a history of trauma.
"My goal is to provide my clients with the opportunity for change. Whether that's exploring life through play, including the family or community system, or focusing on a solution, my job is to help you reach your full potential.
--Alisha Saucedo, LSCSW
Maria Cristina Davila, MD FAPA is a Board Certified Psychiatrist and Psychoanalyst. She owns and operates Awakenings Intensive Outpatient Program (IOP) for adults and adolescents with mental health and substance abuse concerns at 83rd and Mission in Prairie Village. She serves as a consulting psychiatrist for Family Psychological Services and collaborating physician for Kelsey.
Intensive Outpatient Services provide a much needed resource for adults and adolescents who require more than weekly or twice monthly outpatient service, but are not in need of inpatient psychiatric hospitalization. You can reach Awakenings at 913-381-8555.
"I believe in real collaboration between patient, therapist, and prescriber. By working as a team we can enhance treatment outcomes.
--Maria Cristina Davila, MD FAPA
Grace, is a Certified Animal Therapist (CAT)*. She assists Dr. Wes by trying to type notes on his laptop during session and napping on the arm of his chair. Lately she's been learning to sit with clients (or on them), but she may ignore you unless you bring string. In fact, she wrote her masters thesis on string theory. Sometimes she plays rough, particularly with boys. Grace likes boys quite a bit. Grace does not like other cats, but she does like puppies as long as they are friendly and cute. She loves birds...which is why we don't usually invite them to session.
If you have allergies to Grace she won't be offended. She can retire to her office or visit with clients in the lobby during your session. Just let us know at the beginning of sessions. Some clients who like cats but are allergic enjoy having this limited exposure to Grace. Dr. Wes does have a HEPA air filter in his office to keep the air clean of allergens.
"Meow. Meow meow meow. Meow. Meow. Purr purr. Snore snore."
--Grace, CAT
*This is a joke. Cats can't be certified as therapists.


text: > View Product Details Please select the size of the product. Please enter valid quantity. Three Dots cobalt jersey knit cowl neck overlay tank top overview details Retail: $80.00 Reduced: $57.99 $57.99 color : We're sorry. This style is sold out. Cobalt If you want to be on-point with your fabulous fashion sense, then hit the style bullseye when you wear adorable tops by Three Dots. Color: Cobalt Lightweight stretch jersey knit Scoop neck Cowl neck overlay at front Sleeveless; tank straps Contemporary fit 95% Viscose / 5% Spandex; Machine Wash; U.S.A; style#323797104


text:
It was while pursuing M.A. English in St. Stephen's College, Ashok Vajpeyi decided to write in his mother tongue
I came to this college only for my M.A, in English (1960-62), so the sense of belonging to the college more seriously did not occur in my case. Only the tutorials and residence was in the college, the classes used to be held in the University.
That apart, I had come from a small town. I graduated from Sagar University, a big shock for me was that I was not used to speaking so much English, I spoke mostly in Hindi. I did my schooling and B.A. in Hindi medium. But by the time I came here I had already exposed my mind to writers like Rilke, Pablo Neruda, to Kafka, Albert Camus and Paul Valery and so on. I was quite deeply interested in world literature, which as a young writer I had sort of imbibed. So when I came here I found that my classmates had studied in Doon School, Scindia School, Mayo College and all that. Since they had studied in English medium throughout, they knew everything about English literature. I knew more about world literature and that gave me a bit of confidence and that's how the transition, in a certain sense, started.
There used to be a librarian who used to tell me a joke about Girija Shankar Bajpai. He was an ICS officer, the first High Commissioner of India after Independence and the joke was that he was once going on a London street and inadvertently or by mistake an Englishman bumped into him and profusely apologised, but he was not pacified, a) he was a Bajpai – they are all arrogant, without exceptions, some of them are talented, b) he was an ICS officer and c) he was the first Indian High Commissioner in London, so this was arrogance raised to power three.In exasperation he said, "Don't you know that I am Sir Girija Shankar Bajpai". By that time the Englishman had enough and he reacted, "I don't know what pie you are, but if you don't behave on a London street I'm going to make a mince pie out of you."
Those days we were not co-educational, so we used to get girls from Miranda House, they used to come as actresses for our Shakespearean productions and also for love I think. Stephanians were remarkably elegant and also quite remarkably arrogant.
But being here I got the chance of watching, deepening and expanding my levels of cultural literacy, I used to run away from the college to attend classical music concerts, go to art galleries, dance recitals and things like that. Many a times it used to get very late, so I had to arrange for my dinner outside, and I must say that my fellow residents, used to take care of it. I mean they would sometimes go to Kamla Nagar and sell raddi or beer bottles.
Incidentally I had my first ever drink in my life sitting in the bushes of the Stephanian playground near Kashmere Gate. At that time we could buy only beer, other drinks were not readily available.
The dining hall used to be a horror in particular, I became a non-vegetarian by accident I was a stubborn vegetarian at home. On the first day I entered the dining room for lunch and I occupied the first available space on the table, I didn't want to be noticed finding where vegetarian and non-vegetarian is because that meant that I would be spotted out as a fresher. So I sat on a table which turned out to be the non-vegetarian table. Again for the fear of being noticed, I took whatever was available and I started liking it.
One of the things that used to intrigue me was that they would say that the dining tables of our college were exact replicas of the King's College dining tables, I thought that must be a matter of shame rather than adulation.
But all said and done it made a very deep impact on me, in the sense that while there, studying English literature and living in this highly imitative English atmosphere, I very firmly decided to write in my own mother tongue. I have been asked this question later by BBC etc., "How is it that you never write in English?" I said I never spent my childhood in English and I never dream in English."
Keywords: Ashok Vajpeyi, cultural literacy, St. Stephen's College, Indian poets


text:
Cuzco Sterling Rainbow Ring
Roll over image to zoom in
☆ Special Selection -- one of our favorites!
Bring one of earth's most magnificent splendors to your fingertips with our rainbow-inspired sterling ring! Bands of natural, colorful stones are arranged together and inset beautifully in sterling silver to create a timeless and inspiring accessory.
- .925 sterling silver, serpentine, sodalite, spondilus, mother of pearl, and turquoise
- Appoximately 0.5" W (1.3 cm)
- Handmade in and fairly traded from Peru
Ring Sizing: Please choose between U.S.A. ring sizes 6, 7, 8, 9, or 10. For conversions to other countries' ring sizes, see our Ring Sizes Page.
For bulk pricing on these and other items, please contact our Customer Service department at email@example.com.
People buying this item also bought:
From $3.95
Additional sizes available...
From $4.95
Purple Paw Ultralite™ Gradient Shoes
Buy a Pair, Give a Pair
From $3.99
On Sale!
Purple Paws & Hearts Lightweight Pajama Set
From $34.95
Paw Print Birthstone Sterling Ring
From $29.99
On Sale!
Wings of an Angel Purple Paw Tank Top
From $14.95
Center Stage Embroidered Paw Print Hooded Jacket
From $42.95
Gives $5 To Nepal
From $10.00
Special Value!
Kitten in Flowers Solar Garden Stake
From $19.95
Paws Galore™ SuperCozy™ Fleece Blanket
From $29.00
Special Value!
Winged Bling Paw Print Military Hat
From $12.99
On Sale!
From $3.99
On Sale!
From $16.95
From $1.00
Wings of an Angel Purple Paw Mug
From $9.00
Special Value!
From $1.00
From $6.00
Special Value!
Walk With a Friend Hooded Sweatshirt
From $39.95
Recent reviews:
January 9, 2015 - I ordered both the horizontal and diagonal rings, one for me, one for my sister. We love them! My sister kept the diagonal one, and after wearing it about a week, the yellow stripe fell out and was lost. I contacted customer service, and they are mailing a new ring, free of charge! Great service, and beautiful rings!!
July 19, 2014 - I bought this ring because it matches earrings which have the very same stones colors and diagonal design. They look great together and go with just about any outfit. I really enjoy wearing them.
September 10, 2013 - Its perfect! I love this ring. It's worth every penny that I paid for it! Thank you.
April 18, 2013 - What a beautiful ring - great quality for a low price. I love it!
July 24, 2012 - A beautiful ring. I have purchased both the horizontal and diagonal.
Popular Now:
Only Speaking To My Dog Tank Top
From $12.99
On Sale!
Only Speaking To My Cat! T-Shirt
From $17.95
Adopted & Adored™ Cat Magnet Notepad
From $3.00
Special Value!
From $16.99
On Sale!
Help Sterilize and Vaccinate Homeless Cats
From $1.00
Cozy Kitties Grande Ceramic Mug
From $7.99
On Sale!
Only Speaking To My Cat Hooded Sweatshirt
From $39.95
From $5.00
All You Need Is Love & A Cat 3/4 Sleeve Baseball Tee
From $21.99
On Sale!
From $23.95
From $2.00
Special Value!
Protect Shelter Cats with Vaccinations
From $2.00
Blessed By Paws Indoor/Outdoor Mat
From $11.00
Special Value!