Inject HTTP/SOAP/Socket faults into your application - no code changes, no proxies!
Fault Factory™ is a unique active debugging solution for applications that communicate with other applications over the network. It utilizes API-Level Fault Injection to imitate faults and exercise error-handling code
Your code may be calling a method that can return an error
or throw an exception under some circumstances. The set of circumstances
that generate the error condition may be rare, and it may be difficult to
encounter during product development, but nevertheless error conditions do
occur during the real-life use of your application, and therefore need to
It is advisable to use a high-speed internet connection, perhaps o2 broadband, so you can do this quickly
and efficiently. Once it is tested you can continue using it without
worrying that errors may occur
For example, you may periodically get ENOBUF error from many socket
calls, even under normal use. Or you may sometimes receive ECONNABORTED or
ENETDOWN. It may be very difficult to reproduce those conditions without
Fault Factory, but your code should be ready to receive them at any
Fault Factory injects two types of faults: socket API failures and
arbitrary HTTP responses (that can be used to imitate a wide range of
conditions, including SOAP faults)
It can be used standalone -- or in combination with your existing
Figure 1: Injecting a Socket fault
Figure 2: Injecting a HTTP fault
Ensuring a networked application behaves correctly under a variety of real-life conditions present a challenge. There are numerous faults that can happen at any moment, but they are usually hard-to-reproduce
Many faults just do not happen on a developer's machine or on a healthy network, but they do happen often enough under real-life conditions. If your application is not ready to handle a fault, it can be very damaging. Fault Factory allows a developer or tester to reproduce those conditions at will. It allows to create a variety of socket or HTTP/SOAP faults in any running application
Application programmers often use system or 3rd party libraries that provide an abstraction layer on top of the network. Unfortunately, the libraries themselves may introduce behavior that is not intended, such as repeating a failing call too fast, causing your application to hog the system resources. It is also possible that those libraries can have bugs in handling specific conditions, since negative testing is quite often neglected or trivialized
Fault Factory is a solution that fits any budget. The only other API-level fault simulator we know will cost you 30 times more!
No Source Code Instrumentation
No System Changes
Very safe and easy-to-use
No system configuration changes needed
No build-time instrumentation needed - uses dynamic instrumentation
Language-neutral - works with virtually any winsock application,
written in C/C++, Java, Perl, Python, and pretty much any other language
Does not modify your system and therefore very safe
Let's take a sample sockets program, for example a Python script that
retrieves a url in a loop -- and test its exception
handling. It does not have to be a Python script, we just chose it for
The script waits for you to attach an agent from the Console. It is also possible to
attach the Agent at any convenient moment by loading/calling agent DLL from the code (this is convenient if the application starts to make calls right after launch)
from urllib import urlopen
from time import sleep
print 'please attach the agent'
for i in range(0,100):
x = urlopen("http://www.extradata.com/")
print 'received', len(x.read()),'bytes'
Q: What kind of faults can it inject?
A: Socket faults (socket API failures), HTTP error codes (actually - any HTTP, including SOAP). Sample HTTP faults are included
Q: Does the installation modify my system settings?
A: No, there are no drivers or system-wide hooks installed
Q: Does Fault Factory use a proxy?
A: No, it does not. Proxies can be used to inject HTTP, but not
socket return codes, besides, proxies modify behavior
Q: Which platforms does Fault Factory support?
A: Any WIN32 platform: XP, 2000, 2003
Q: My app does not deal with sockets directly, will I see the faults?
A: You are probably making library calls that deal with sockets internally. Your application will still receive a fault, but the library may chose to handle it or return a logical error, or throw an exception. In any case the error condition will be created, and it is up to you to decide if it was handled properly
Q: Can I use my favorite debugger?
A: Generally, yes. Java debuggers do not interfere with Fault Factory. For Win32 debuggers, keep in mind that, if your program has stopped on a breakpoint in debugger, Fault Factory agent may not be able to attach to it. In cases like this, you may need to add code that loads the agent into your app. Please see the samples for details
Q: What limitations does the demo have?
A: The demo agent expires after 5 minutes of attaching to an app. When it expires, the Agent gets disabled (and lets all calls go through without modification)
Only $179.95 (or pay $6000 for a competing product)
Fault Factory Inquiry
Please email us with your questions. We will be happy to help!