EventFake does not match Event:listen documentation - both need fixing

[Sophist-UK]

Laravel Version

9.x, 10.x, 11.x, 12.x

PHP Version

All supported

Database Driver & Version

None

Description

As far as I can tell this is an issue with all versions of Laravel back to at least v9.

The documentation at https://laravel.com/docs/events#manually-registering-events says that you should manually associate events and listeners in your service provider like this:

public function boot()
{
    Event::listen(
        PodcastProcessed::class,
        [SendPodcastNotification::class, 'handle']
    );
}

however the deprecated EventFaker documentation says:

Event::fake();
Event::assertListening(PodcastProcessed::class, SendPodcastNotification::class);

The code in v9.x framework/src/Illuminate/Support/Testing/Fakes/EventFake.php clearly suggests that you can specify listeners as either "class@method" or ["class", "method"].

It turns out that there are (IMO) three algorithmic bugs in the assertListening method:

1. The expected and actual listeners are not independently normalised when they should be - when the actual listener is NOT specified as "class@method", the expected listener is not normalised.
2. The documentation suggests that the expected listener should be specified just as a class name, and this is incorrect - currently it needs to be specified as either "class@method" or "[class, method]'.
3. IMO (and this is a personal opinion) if the expected listener is specified as only "class" and not one of the two methods in point 2., then it should match based only on classes and not on method.

Solution

1. See proposed code fix below.
2. Restore EventFaker documentation from 8.x to later versions.
3. Improve the Event Listener documentation to document the use of "class@method".

Steps To Reproduce

https://github.com/laravel/framework/blob/9.x/src/Illuminate/Support/Testing/Fakes/EventFake.php#L90-L103 are:

    public function assertListening($expectedEvent, $expectedListener)
    {
        foreach ($this->dispatcher->getListeners($expectedEvent) as $listenerClosure) {
            $actualListener = (new ReflectionFunction($listenerClosure))
                        ->getStaticVariables()['listener'];

            $normalizedListener = $expectedListener;

            if (is_string($actualListener) && Str::contains($actualListener, '@')) {
                $actualListener = Str::parseCallback($actualListener);

                if (is_string($expectedListener)) {
                    if (Str::contains($expectedListener, '@')) {
                        $normalizedListener = Str::parseCallback($expectedListener);
                    } else {
                        $normalizedListener = [
                            $expectedListener,
                            method_exists($expectedListener, 'handle') ? 'handle' : '__invoke',
                        ];
                    }
                }
            }

            if ($actualListener === $normalizedListener ||
                ($actualListener instanceof Closure &&
                $normalizedListener === Closure::class)) {
                PHPUnit::assertTrue(true);

                return;
            }
        }

        PHPUnit::assertTrue(
            false,
            sprintf(
                'Event [%s] does not have the [%s] listener attached to it',
                $expectedEvent,
                print_r($expectedListener, true)
            )
        );
    }

and IMO should be:

    public function assertListening($expectedEvent, $expectedListener)
    {
        $normalizedListener = $expectedListener;

        if (is_string($normalizedListener) && Str::contains($normalizedListener, '@')) {
            $normalizedListener = Str::parseCallback($normalizedListener);
        }

        foreach ($this->dispatcher->getListeners($expectedEvent) as $listenerClosure) {
            $actualListener = (new ReflectionFunction($listenerClosure))
                ->getStaticVariables()['listener'];

            if (is_string($actualListener) && Str::contains($actualListener, '@')) {
                $actualListener = Str::parseCallback($actualListener);
            }

            if (is_string($normalizedListener) && is_array($actualListener)) {
                $actualListener = $actualListener[0];
            }

            if ($actualListener === $normalizedListener ||
                ($actualListener instanceof Closure &&
                $normalizedListener === Closure::class)) {
                PHPUnit::assertTrue(true);

                return;
            }
        }

        PHPUnit::assertTrue(
            false,
            sprintf(
                'Event [%s] does not have the [%s] listener attached to it',
                $expectedEvent,
                print_r($expectedListener, true)
            )
        );
    }

[crynobone]

Restore EventFaker documentation from 8.x to later versions.

The documentation was moved, not deprecated: https://laravel.com/docs/12.x/events#testing

See proposed code fix below.

Can you submit failing tests to describe the issue to this repository?

[Sophist-UK]

composer create-project laravel/laravel:9.x EventFakerTest
php artisan make:event TestEvent
php artisan make:listener TestListener --event=TestEvent
rm tests/Feature/ExampleTest.php tests/Unit/ExampleTest.php
php artisan make:test EventFaker

EventFakerTest.php

<?php

namespace Tests\Unit;

use App\Events\TestEvent;
use App\Listeners\TestListener;
use Illuminate\Support\Facades\Event;
use Tests\TestCase;

class EventFakerTest extends TestCase
{
    public function setup():void
    {
        parent::setup();
        Event::fake();
    }

    /**
     * The following are (or should be) functionally identical:
     *
     * Event::listen(TestEvent::class, TestListener::class);
     * Event::listen(TestEvent::class, [TestListener::class]);
     * Event::listen(TestEvent::class, [TestListener::class, 'handle']);
     * Event::listen(TestEvent::class, TestListener::class . '@handle');
     *
     * because the same Event triggers the same method of the same Listener.
     *
     * Since you don't necessarily know which of the above forms the listener was attached with
     * testing for one should match against the others.
     *
     **/

    public function test_matched_assertListening_class_only()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_matched_assertListening_class_list()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_matched_assertListening_class_and_method()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }

    public function test_matched_assertListening_class_at_method()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_matched_assertListening_class_only_vs_class_list()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_mismatched_assertListening_class_only_vs_class_and_method()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }

    public function test_mismatched_assertListening_class_only_vs_class_at_method()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_matched_assertListening_class_list_vs_class_only()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_mismatched_assertListening_class_list_vs_class_and_method()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }

    public function test_mismatched_assertListening_class_list_vs_class_at_method()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_mismatched_assertListening_class_and_method_vs_class_only()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_matched_assertListening_class_and_method_vs_class_list()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_mismatched_assertListening_class_and_method_vs_class_at_method()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_mismatched_assertListening_class_at_method_vs_class_only()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_matched_assertListening_class_at_method_vs_class_list()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_mismatched_assertListening_class_at_method_vs_class_and_method()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }
}

Results with L9.x:

php artisan test
   FAIL  Tests\Unit\EventFakerTest                                                                                               
  ✓ matched assert listening class only                                                                                          
  ✓ matched assert listening class list                                                                                          
  ✓ matched assert listening class and method                                                                                    
  ✓ matched assert listening class at method                                                                                     
  ⨯ matched assert listening class only vs class list                                                                            
  ⨯ mismatched assert listening class only vs class and method                                                                   
  ⨯ mismatched assert listening class only vs class at method                                                                    
  ⨯ matched assert listening class list vs class only                                                                            
  ⨯ mismatched assert listening class list vs class and method                                                                   
  ⨯ mismatched assert listening class list vs class at method                                                                    
  ⨯ mismatched assert listening class and method vs class only                                                                   
  ⨯ matched assert listening class and method vs class list                                                                      
  ⨯ mismatched assert listening class and method vs class at method                                                              
  ✓ mismatched assert listening class at method vs class only                                                                    
  ⨯ matched assert listening class at method vs class list                                                                       
  ✓ mismatched assert listening class at method vs class and method                                                              
                                                                                                                                 
  ---                                                                                                                            
                                                                                                                                 
  • Tests\Unit\EventFakerTest > matched assert listening class only vs class list                                                
  Event [App\Events\TestEvent] does not have the [Array                                                                          
  (                                                                                                                              
      [0] => App\Listeners\TestListener                                                                                          
  )                                                                                                                              
  ] listener attached to it                                                                                                      
  Failed asserting that false is true.                                                                                           
                                                                                                                                 
  at D:\GitClones\Github\Tranzakt\EventFakerTest\vendor\laravel\framework\src\Illuminate\Support\Testing\Fakes\EventFake.php:114 
    110▕                 return;                                                                                                 
    111▕             }                                                                                                           
    112▕         }                                                                                                               
    113▕                                                                                                                         
  ➜ 114▕         PHPUnit::assertTrue(                                                                                            
    115▕             false,                                                                                                      
    116▕             sprintf(                                                                                                    
    117▕                 'Event [%s] does not have the [%s] listener attached to it',                                            
    118▕                 $expectedEvent,                                                                                         
                                                                                                                                 
  1   D:\GitClones\Github\Tranzakt\EventFakerTest\vendor\laravel\framework\src\Illuminate\Support\Facades\Facade.php:338         
      Illuminate\Support\Testing\Fakes\EventFake::assertListening("App\Events\TestEvent")                                        
                                                                                                                                 
  2   D:\GitClones\Github\Tranzakt\EventFakerTest\tests\Unit\EventFakerTest.php:60                                               
      Illuminate\Support\Facades\Facade::__callStatic("assertListening")                                                         

...
                             
  Tests:  10 failed, 6 passed
  Time:   0.84s              

[Sophist-UK]

I tried my version of the code and made some further changes and here is an improved version of the code (and a minor tweak to remove duplication):

    /**
     * Assert if an event has a listener attached to it.
     *
     * @param  string  $expectedEvent
     * @param  string|array  $expectedListener
     * @return void
     */
    public function assertListening($expectedEvent, $expectedListener)
    {
        $normalizedListener = $expectedListener;

        if (is_array($normalizedListener) && count($normalizedListener) == 1 && is_string($normalizedListener[0])) {
            $normalizedListener = $normalizedListener[0];
        }

        if (is_string($normalizedListener)) {
            if (Str::contains($normalizedListener, '@')) {
                $normalizedListener = Str::parseCallback($normalizedListener);
            } else {
                $normalizedListener = [$normalizedListener, 'handle'];
            }
        }

        foreach ($this->dispatcher->getListeners($expectedEvent) as $listenerClosure) {
            $actualListener = (new ReflectionFunction($listenerClosure))
                ->getStaticVariables()['listener'];

            if (is_array($actualListener) && count($actualListener) == 1 && is_string($actualListener[0])) {
                $actualListener = $actualListener[0];
            }

            if (is_string($actualListener)) {
                if (Str::contains($actualListener, '@')) {
                    $actualListener = Str::parseCallback($actualListener);
                } else {
                    $actualListener = [$actualListener, 'handle'];
                }
            }

            if ($actualListener === $normalizedListener ||
                ($actualListener instanceof Closure &&
                $normalizedListener === Closure::class)) {
                PHPUnit::assertTrue(true);

                return;
            }
        }

        PHPUnit::assertTrue(
            false,
            sprintf(
                'Event [%s] does not have the [%s] listener attached to it',
                $expectedEvent,
                print_r($expectedListener, true)
            )
        );
    }

Removing duplication:

    /**
     * Assert if an event has a listener attached to it.
     *
     * @param  string  $expectedEvent
     * @param  string|array  $expectedListener
     * @return void
     */
    public function assertListening($expectedEvent, $expectedListener)
    {
        $normalizedListener = $this->parseListener($expectedListener);

        foreach ($this->dispatcher->getListeners($expectedEvent) as $listenerClosure) {
            $actualListener = $this->parseListener((new ReflectionFunction($listenerClosure))
                ->getStaticVariables()['listener']);

            if ($actualListener === $normalizedListener ||
                ($actualListener instanceof Closure &&
                $normalizedListener === Closure::class)) {
                PHPUnit::assertTrue(true);

                return;
            }
        }

        PHPUnit::assertTrue(
            false,
            sprintf(
                'Event [%s] does not have the [%s] listener attached to it',
                $expectedEvent,
                print_r($expectedListener, true)
            )
        );
    }

    protected function parseListener($listener)
    {
        if (is_array($listener) && count($listener) == 1 && is_string($listener[0])) {
            $listener = $listener[0];
        }

        if (is_string($listener)) {
            if (Str::contains($listener, '@')) {
                $listener = Str::parseCallback($listener);
            } else {
                $listener = [$listener, 'handle'];
            }
        }

        return $listener;
    }

[Sophist-UK]

Additionally I would propose that we implement wildcard tests - so if you explicitly specify an expected listener method containing a "*" then any matching actual listener classes would make assertListening pass.

<?php

namespace Tests\Unit;

use App\Events\TestEvent;
use App\Listeners\TestListener;
use Illuminate\Support\Facades\Event;
use Tests\TestCase;

class EventFakerTest extends TestCase
{
    public function setup():void
    {
        parent::setup();
        Event::fake();
    }

    /**
     * The following are (or should be) functionally identical:
     *
     * Event::listen(TestEvent::class, TestListener::class);
     * Event::listen(TestEvent::class, [TestListener::class]);
     * Event::listen(TestEvent::class, [TestListener::class, 'handle']);
     * Event::listen(TestEvent::class, TestListener::class . '@handle');
     *
     * because the same Event triggers the same method of the same Listener.
     *
     * Since you don't necessarily know which of the above forms the listener was attached with
     * testing for one should match against the others.
     *
     * Additionally, if you explicitly specify the expected method containing a * then
     * it should match any listeners that match on wildcards.
     **/

    public function test_matched_assertListening_class_only()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_matched_assertListening_class_list()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_matched_assertListening_class_and_method()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }

    public function test_matched_assertListening_class_at_method()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_matched_assertListening_class_only_vs_class_list()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_mismatched_assertListening_class_only_vs_class_and_method()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }

    public function test_mismatched_assertListening_class_only_vs_class_at_method()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_matched_assertListening_class_list_vs_class_only()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_mismatched_assertListening_class_list_vs_class_and_method()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }

    public function test_mismatched_assertListening_class_list_vs_class_at_method()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_mismatched_assertListening_class_and_method_vs_class_only()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_mismatched_assertListening_class_and_method_vs_class_list()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_mismatched_assertListening_class_and_method_vs_class_at_method()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, TestListener::class . '@handle');
    }

    public function test_mismatched_assertListening_class_at_method_vs_class_only()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_mismatched_assertListening_class_at_method_vs_class_list()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, [TestListener::class]);
    }

    public function test_mismatched_assertListening_class_at_method_vs_class_and_method()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, [TestListener::class, 'handle']);
    }

    public function test_mismatched_assertListening_class_list_vs_class_only()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, TestListener::class);
    }

    public function test_wildcard_assertListening_class_only_vs_class_and_method()
    {
        Event::listen(TestEvent::class, TestListener::class);
        Event::assertListening(TestEvent::class, [TestListener::class, 'hand*']);
    }

    public function test_wildcard_assertListening_class_only_vs_class_at_method()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, TestListener::class . '@hand*');
    }

    public function test_wildcard_assertListening_class_list_vs_class_and_method()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, [TestListener::class, 'hand*']);
    }

    public function test_wildcard_assertListening_class_list_vs_class_at_method()
    {
        Event::listen(TestEvent::class, [TestListener::class]);
        Event::assertListening(TestEvent::class, TestListener::class . '@hand*');
    }

    public function test_wildcard_assertListening_class_and_method_vs_class_and_method()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, [TestListener::class, 'hand*']);
    }

    public function test_wildcard_assertListening_class_and_method_vs_class_at_method()
    {
        Event::listen(TestEvent::class, [TestListener::class, 'handle']);
        Event::assertListening(TestEvent::class, TestListener::class . '@hand*');
    }

    public function test_wildcard_assertListening_class_at_method_vs_class_and_method()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, [TestListener::class, 'hand*']);
    }

    public function test_wildcard_assertListening_class_at_method_vs_class_at_method()
    {
        Event::listen(TestEvent::class, TestListener::class . '@handle');
        Event::assertListening(TestEvent::class, TestListener::class . '@hand*');
    }
}

    /**
     * Assert if an event has a listener attached to it.
     *
     * @param  string  $expectedEvent
     * @param  string|array  $expectedListener
     * @return void
     */
    public function assertListening($expectedEvent, $expectedListener)
    {
        $normalizedListener = $this->parseListener($expectedListener);

        foreach ($this->dispatcher->getListeners($expectedEvent) as $listenerClosure) {
            $actualListener = $this->parseListener((new ReflectionFunction($listenerClosure))
                ->getStaticVariables()['listener']);

            if ($actualListener === $normalizedListener ||
                ($actualListener instanceof Closure &&
                $normalizedListener === Closure::class) ||
                (is_array($actualListener) && is_array($normalizedListener) &&
                count($actualListener) === count($normalizedListener) &&
                count($actualListener) === 2 &&
                $actualListener[0] === $normalizedListener[0] &&
                Str::is($normalizedListener[1], $actualListener[1])))
           {
                PHPUnit::assertTrue(true);

                return;
            }
        }

        PHPUnit::assertTrue(
            false,
            sprintf(
                'Event [%s] does not have the [%s] listener attached to it',
                $expectedEvent,
                print_r($expectedListener, true)
            )
        );
    }

    protected function parseListener($listener)
    {
        if (is_array($listener) && count($listener) == 1 && is_string($listener[0])) {
            $listener = $listener[0];
        }

        if (is_string($listener)) {
            if (Str::contains($listener, '@')) {
                $listener = Str::parseCallback($listener);
            } else {
                $listener = [$listener, 'handle'];
            }
        }

        return $listener;
    }

[Sophist-UK]

Happy to submit the above as a code/test PR and as a Docs PR - just advise which version(s) of Laravel you would like these to apply to (and if multiple versions your preferred way for me to submit PRs to them all).

[pandiselvamm]

Hi @Sophist-UK @crynobone created PR #54907

Edited: I have used your suggestion code and written test case too , credits to @Sophist-UK

[Sophist-UK]

@pandiselvamm I really do NOT appreciate your rank plagiarism of my own hard work!!!!

This is both disrespectful and contrary to both the Github and Laravel codes of conduct, and indeed breach of copyright since unless I explicitly say otherwise, my code is Copyright me and I have not given you permission to use it in a PR.

[pandiselvamm]

Sorry @Sophist-UK , I tried to add you as co author in it just raised your pr with suggestion code here I won't taken your credits but sorry about that , you can see my commit time I have committed before you mentioned that I going to raise PR but I tried to add you as a authour

It was done mistakenly apologize for that

[Sophist-UK]

@pandiselvamm

Perhaps this is a mistake of a relative novice - or perhaps it is a sign of a newcomer trying to establish a history of open source contributions to boost his credentials and help his career by stealing the efforts of others..

A few minutes ago I was able to see your contribution history but NOW it is hidden - so apparently you have now chosen to hide this from me which is NOT a sign of someone repentant about an honest mistake.

If you don't want to get a PUBLIC reputation for stealing other people's efforts, then you need to stop doing it and be more genuinely apologetic.

[Sophist-UK]

@pandiselvamm More to the point, @taylorotwell has rejected the PR you submitted, perhaps because you didn't justify it well enough. So not only did you steal my efforts, but you have also caused them to be rejected.

So now, having already spent quite a lot of effort finding a workaround for my PR elsewhere that ran into this problem, and then spending effort in writing a set of tests, and then more effort in writing a solution, I now have to spend even more of my time attempting to undo the damage you have done.

[Sophist-UK]

@pandiselvamm I would suggest that in future you limit writing PRs for other people's issues to those which have the "Help Wanted" tag.

[pandiselvamm]

Okay sure @Sophist-UK , it was done mistakenly if am doing this again I will try to add co author my code also used as co author I thought like that we can do but I can't

In future I will follow this , I apologise for my mistake for not added as a author on to it

[Sophist-UK]

@pandiselvamm

1. If you steal someone else's code then you do NOT have the right to submit it in your own PR. Period!!

2. If you do submit it as a PR, then doing this does NOT make you a co-author!!

This has got to be the least sincere apology ever offered - not a single apology for stealing my code and then rendering my efforts wasted - just a statement that next time you steal my code you will tell everyone that you co-wrote it.

I suggest that you book yourself onto an Ethics 101 course - because right now you seem to me to be completely lacking in them.