The Lounge - CodeProject

I still have my 8088 chip; my InBoard 386 that replaced; the 5150 and "steel" keyboard; XT expansion drive; etc.

I'd play Robotron on the 8088; when I dropped in the 386, I was out swarmed in 2 seconds. Nobody used "wall time" back then; just cycles. Amazing how much software could not run "faster" back then.

(And if your system had more than 256K (custom in board), an app could start "wrapping memory" ... because: it's not possible to have that much memory).

"Before entering on an understanding, I have meditated for a long time, and have foreseen what might happen. It is not genius which reveals to me suddenly, secretly, what I have to say or to do in a circumstance unexpected by other people; it is reflection, it is meditation." - Napoleon I

Gerry Schmitz wrote:
Robotron

I'm almost ashamed to admit that at some point '82 or '83, I could play Robotron the entire day on 1 quarter. I'd have to leave because they closed for the night, never did find out how long I could have played.

"the debugger doesn't tell me anything because this code compiles just fine" - random QA comment
"Facebook is where you tell lies to your friends. Twitter is where you tell the truth to strangers." - chriselst
"I don't drink any more... then again, I don't drink any less." - Mike Mullikins uncle

I broke with a mace an old PIII PC! I felt like d&d quest!

Laugh | :laugh:

Critical hit: power supply. Roll a save +5 against shock.

I have lived with several Zen masters - all of them were cats.

His last invention was an evil Lasagna. It didn't kill anyone, and it actually tasted pretty good.

This morning, I got a call from my brother who owns a tool and die shop. It seems that the last 3.5 floppy disk he had been using to load programs into the cncs gave up the ghost... so having a usb connected floppy drive, figured no problem...get a good fresh one, tape over the hole and format it to the required 720KB settings using Win10 cmd. Nope, nada...apparently, it's an issue with the usb connected floppy drive.

He found an old Win98 box, hooked it up and after updating the clock, got it up and running, then formatted a dozen floppies successfully. It's great when old h/w can still serve a purpose. Laugh | :laugh:

"Go forth into the source" - Neal Morse
"Hope is contagious"

CodeWraith wrote:
How many owners of old XTs are looking for old drives which still have an 8 bit mode.

Those people should be locked away and segregated from the rest of humanity. Forever. With their failed hard drives.

".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013

#realJSOP wrote:
Forever

Forever can be shorter than you think. Just wait until the next bug strikes and new and shiny gets even harder to get than it is at the moment. Half of the younger generation would die within a few days without their brain pacemakers. Never thought that you would be so dependent on gadgets.

I have lived with several Zen masters - all of them were cats.

His last invention was an evil Lasagna. It didn't kill anyone, and it actually tasted pretty good.

Just using the VS built in stuff, and I've migrated all my Range tests (with a couple added to cover cases I'd missed Blush | :O

).
I kinda like it:

C#

using System;
using NonContiguousRange;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Linq;

namespace RangeTests
    {
    [TestClass]
    public class RangeTester
        {
        // Useful test constructors:
        private Range ra = new Range(0, 4);       // 
        private Range rb = new Range(5, 9);       // Contiguous with ra
        private Range rc = new Range(10, 14);     // Contiguous with rb
        private Range rd = new Range(1, 3);       // Intersects ra, not contiguous with rb
        private Range re = new Range(6, 8);       // Intersects rb, not contiguous with rc
        private Range rf = new Range(16, 19);     // Not contiguous with anything.
        private Range rg = new Range(0, 0);       // Single element.
        private Range rh = new Range(1, 1);       // Single element.
        private Range ri = new Range(2, 2);       // Single element.
        private Range rj = new Range(0, 19);      // All elements.
        private Range rk = new Range(0, 4);       // Identical to ra
        private Range rl = new Range(-1, 1);      // Overlap start ra
        private Range rm = new Range(3, 5);       // Overlap end ra
        private string testType = "";

        #region Tests
        [TestMethod]
        public void ConstructorsTest()
            {
            testType = "\nConstructor";
            Assert.AreEqual(5, ra.Count, 0, $"{testType}: Range items count incorrect");
            Assert.AreEqual(0, ra.Min, 0, $"{testType}: Range minimum incorrect");
            Assert.AreEqual(4, ra.Max, 0, $"{testType}: Range maximum incorrect");
            Check(ra, new int[] { 0, 1, 2, 3, 4 }, "Wrong elements");
            Check(new Range(new int[] { 0, 1, 2, 5, 6, 7 }.AsEnumerable()), new int[] { 0, 1, 2, 5, 6, 7 }, "Enumerable parameter wrong elements");
            }
        [TestMethod]
        public void HumanReadabilityTest()
            {
            testType = "\nHuman Readability";
            Assert.AreEqual("(0:4)", ra.ToString(), false, $"{testType}: Contiguous range incorrect");
            Assert.AreEqual("(0:4) | (6:8)", ra.UnionWith(re).ToString(), false, $"{testType}: Noncontiguous range incorrect");
            }
        [TestMethod]
        public void Emptyness()
            {
            testType = "\nEmptiness";
            Assert.IsTrue(Enumerable.SequenceEqual(Range.GetEmpty(), new int[0]), $"{testType}: Empty isn't");
            }
        [TestMethod]
        public void Unions()
            {
            testType = "\nUnions";
            Check(ra.UnionWith(ra), new int[] { 0, 1, 2, 3, 4 }, "Self union");
            Check(ra.UnionWith(rb), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, "Contiguous 1");
            Check(rb.UnionWith(rc), new int[] { 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }, "Contiguous 2");
            Check(ra.UnionWith(rc), new int[] { 0, 1, 2, 3, 4, 10, 11, 12, 13, 14 }, "Noncontiguous 1");
            Check(ra.UnionWith(re), new int[] { 0, 1, 2, 3, 4, 6, 7, 8 }, "Noncontiguous 2");
            Check(ra.UnionWith(rg), new int[] { 0, 1, 2, 3, 4 }, "Single element in original range");
            Check(rd.UnionWith(rg), new int[] { 0, 1, 2, 3 }, "Single element contiguous");
            Check(rb.UnionWith(rg), new int[] { 0, 5, 6, 7, 8, 9 }, "Single element noncontiguous");
            Check(rg.UnionWith(rh).UnionWith(ri), new int[] { 0, 1, 2 }, "Three single element contiguous");
            Assert.AreEqual(10, ra.UnionWith(rc).Count, 0, $"{testType}: Count");
            Assert.AreEqual(0, ra.UnionWith(rc).Min, 0, $"{testType}: Minimum value");
            Assert.AreEqual(14, ra.UnionWith(rc).Max, 0, $"{testType}: Maximum value");
            }
        [TestMethod]
        public void Intersections()
            {
            testType = "\nIntersections";
            Check(ra.Intersecting(ra), new int[] { 0, 1, 2, 3, 4 }, "Self");
            Check(ra.Intersecting(rl), new int[] { 0, 1 }, "Left intersection");
            Check(ra.Intersecting(rd), new int[] { 1, 2, 3 }, "Center intersection");
            Check(ra.Intersecting(rm), new int[] { 3, 4 }, "Right intersection");
            Check(ra.Intersecting(rb), new int[0], "Contiguous 1");
            Check(rb.Intersecting(rc), new int[0], "Contiguous 2");
            Check(ra.Intersecting(rc), new int[0], "Noncontiguous, non-intersecting");
            Check(ra.Intersecting(rg), new int[] { 0 }, "Single element, intersecting");
            Check(rb.Intersecting(rg), new int[0], "Single element, non-intersecting");
            Check(rg.Intersecting(rh).Intersecting(ri), new int[0], "Single element, single element");
            }
        [TestMethod]
        public void Exceptions()
            {
            testType = "\nExceptions";
            Check(ra.Excepting(ra), new int[0], "Self");
            Check(ra.Excepting(rl), new int[] { 2, 3, 4 }, "Left intersection");
            Check(ra.Excepting(rd), new int[] { 0, 4 }, "Center intersection");
            Check(ra.Excepting(rm), new int[] { 0, 1, 2 }, "Right intersection");
            Check(ra.Excepting(rb), new int[] { 0, 1, 2, 3, 4 }, "Contiguous 1");
            Check(rb.Excepting(rc), new int[] { 5, 6, 7, 8, 9 }, "Contiguous 2");
            Check(ra.Excepting(rc), new int[] { 0, 1, 2, 3, 4 }, "Noncontiguous");
            Check(ra.Excepting(rg), new int[] { 1, 2, 3, 4 }, "Single Element, intersecting 1");
            Check(rj.Excepting(rh).Excepting(rb).Excepting(rf), new int[] { 0, 2, 3, 4, 10, 11, 12, 13, 14, 15 }, "Multiple");
            Check(rg.Excepting(rh).Excepting(ri), new int[] { 0 }, "Multiple single element");
            }
        [TestMethod]
        public void Miscellaneous()
            {
            testType = "\nMiscellaneous";
            Range nc = ra.UnionWith(rf);        // Non contiguous, (0:4) | (16, 19)
            Check(ra.EndAt(19), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, "Expand right, contiguous");
            Check(rf.StartAt(0), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, "Expand left, contiguous");
            Check(nc.EndAt(9), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, "Contract right, non-contiguous");
            Check(nc.StartAt(9), new int[] { 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, "Contract left, non-contiguous");
            Check(ra.UnionWith(re).MakeContiguous(), new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, "Make contiguous");
            }
        [TestMethod]
        public void AddToRange()
            {
            testType = "\nAdding to";
            Check(ra.Add(5), new int[] { 0, 1, 2, 3, 4, 5 }, "Single, right");
            Check(ra.Add(-1), new int[] { -1, 0, 1, 2, 3, 4 }, "Single, left");
            Check(ra.AddRange(new int[] { 5, -1 }), new int[] { -1, 0, 1, 2, 3, 4, 5 }, "Array");
            Check(ra + 5, new int[] { 0, 1, 2, 3, 4, 5 }, "Operator +, single, right");
            Check(ra + -1, new int[] { -1, 0, 1, 2, 3, 4 }, "Operator +, single, left");
            Check(ra + new int[] { 5, -1 }, new int[] { -1, 0, 1, 2, 3, 4, 5 }, "Operator +, array");
            Check(ra + rb, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, "Operator +, range");
            }
        [TestMethod]
        public void RemoveFromRange()
            {
            testType = "\nRemove from range";
            Check(ra.Remove(0), new int[] { 1, 2, 3, 4 }, "Single, left");
            Check(ra.Remove(2), new int[] { 0, 1, 3, 4 }, "Single, center");
            Check(ra.Remove(4), new int[] { 0, 1, 2, 3 }, "Single, right");
            Check(ra.RemoveRange(new int[] { 0, 1 }), new int[] { 2, 3, 4 }, "Array, left");
            Check(ra.RemoveRange(new int[] { 2, 3 }), new int[] { 0, 1, 4 }, "Array, center");
            Check(ra.RemoveRange(new int[] { 3, 4 }), new int[] { 0, 1, 2 }, "Array, right");
            Check(ra - 1, new int[] { 0, 2, 3, 4 }, "Operator -, single");
            Check(ra - -1, new int[] { 0, 1, 2, 3, 4 }, "Operator -, single, not included");
            Check(ra - new int[] { 1, 2 }, new int[] { 0, 3, 4 }, "Operator -, array");
            Check(ra - rd, new int[] { 0, 4 }, "Operator -, range");
            }
        [TestMethod]
        public void Comparisons()
            {
            testType = "\nComparisons";
            Assert.IsTrue(ra.Equals(rk), "Equals");
            Assert.IsTrue(ra.Equals((object)rk), "Equals (object)");
            Assert.IsTrue(ra == rk, "==");
            Assert.IsFalse(ra != rk, "!=");
            }
        [TestMethod]
        public void Contiguousness()
            {
            testType = "\nContiguousness";
            Assert.IsTrue(ra.IsContiguousWith(rb), "Contiguous, right");
            Assert.IsTrue(rb.IsContiguousWith(ra), "Contiguous, left");
            Assert.IsFalse(ra.IsContiguousWith(rc), "NonContiguous, right");
            Assert.IsFalse(re.IsContiguousWith(rd), "Noncontiguous, left");
            }
        [TestMethod]
        public void Intersectivity()
            {
            testType = "\nIntersectivity";
            Assert.IsFalse(ra.IsIntersecting(rb), "Non-intersecting, right");
            Assert.IsFalse(rb.IsIntersecting(ra), "Non-intersecting, left");
            Assert.IsTrue(ra.IsIntersecting(rm), "Intersecting, right");
            Assert.IsTrue(ra.IsIntersecting(rd), "Intersecting, center");
            Assert.IsTrue(rm.IsIntersecting(ra), "Intersecting, left");
            }
        #endregion

        #region Support functions
        /// <summary>
        /// Check a Range result
        /// </summary>
        /// <param name="result"></param>
        /// <param name="expected"></param>
        /// <param name="desc"></param>
        private void Check(Range range, int[] expected, string desc)
            {
            string result = "Range length incorrect";
            if (range.Count == expected.Length)
                {
                result = "Range values did not match";
                if (Enumerable.SequenceEqual(range, expected))
                    {
                    return;
                    }
                }
            ReportFailure(desc, result, range, expected);
            }
        /// <summary>
        /// Report a failure
        /// </summary>
        /// <param name="desc"></param>
        /// <param name="result"></param>
        /// <param name="range"></param>
        /// <param name="expected"></param>
        private void ReportFailure(string desc, string result, string range, string expected)
            {
            Assert.IsTrue(false, $"{testType}: {desc} - {result}\n   Got     : {range}\n   Expected: {expected}");
            }
        /// <summary>
        /// Report a failure
        /// </summary>
        /// <param name="desc"></param>
        /// <param name="result"></param>
        /// <param name="range"></param>
        /// <param name="expected"></param>
        private void ReportFailure(string desc, string result, Range range, int[] expected)
            {
            Assert.IsTrue(false, $"{testType}: {desc} - {result}\n   Got     : {string.Join(", ", range.Select(r => r.ToString()))}\n   Expected: {string.Join(", ", expected.Select(r => r.ToString()))}");
            }
        #endregion
        }
    }

So I thought I'd move to the next step: autogenerating test stubs.

Right click in my project code, and select "Create Unit Tests" expecting ... well, not a lot, but something usable.
All I get is a message box:

MessageBox

Value cannot be null. 
Parameter name: codeClass.

Off to Google ... and lo: Create unit test command fails in STRUCTS[^]
It's a bug that was reported in 2018, and closed a couple of months later with no action. Sigh | :sigh:

Truely, MS do not like to fix bugs - just change the icons and ship it ...

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!

No programming questions in the..........oh, wait. Smile | :)

The difficult we do right away...
...the impossible takes slightly longer.

I just use my own "framework". I hate messing with stuff that's more complicated than it needs to be. Unit testing is straightforward and procedural. There's no reason to have the massive buy-in required by NUnit or MS's framework. KISS. Just my $0.02

Real programmers use butterflies

OriginalGriff wrote:
It's a bug that was reported in 2018

But... but... but... don't they do TDD and Unit Testing? How could there be bugs? Roll eyes | :rolleyes:

If you think 'goto' is evil, try writing an Assembly program without JMP.

As if you didn't know ... Laugh | :laugh:

AMNESIA

A name is    ANAMEIS
troublesome  (anag)

A name is troublesome: AMNESIA

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!

So are you up on Monday ?

"Life should not be a journey to the grave with the intention of arriving safely in a pretty and well-preserved body, but rather to skid in broadside in a cloud of smoke, thoroughly used up, totally worn out, and loudly proclaiming “Wow! What a Ride!" - Hunter S Thompson - RIP

Morning All. I have a bunch of archaic equipment that I manage that uses hard drives with IDE/PATA interfaces. Obviously these are getting hard to find so I'd like to find a reliable IDE to SATA interface. If anyone has an idea of one that works well, please let me know. Thanks in advance!

I don't think you'll have much joy with PATA<->SATA.
I suggest you try for USB to PATA. I've used a couple of no-name ones successfully.

Software rusts. Simon Stephenson, ca 1994. So does this signature. me, 2012

Some of these systems don't even have functional running USB connections. $Shucks | :-\$ I don't think I could get them to boot from them, but thanks for the idea. I might have a couple I can try it on. Smile | :)

Sorry, on reflection I realise I misunderstood your question. I thought you were trying to read old drives pulled from those systems (the kind of thing I do all the time).

Software rusts. Simon Stephenson, ca 1994. So does this signature. me, 2012

Amazon sell them: Amazon.co.uk : IDE to SATA Converter[^]

But ... You'd probably be better off junking them: the youngest IDE HDD drive is probably around 15 years old, so the MB's you are trying to connect your new SATA drives to are going to be pretty aged, and may not like your new drives that much anyway. Remember that many IDE motherboards didn't support HDDs bigger than 30GB without BIOS patches, and the smallest SATA you will find is way bigger than that! There were problems with larger drives with various older OSes as well.

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!

Wish I could. I tried one version that worked for a couple weeks before corrupting. I'm going to try this[^] one from StarTech. Thanks!

I have a lot of IDE drives too.

When I want to connect them to modern PC I use something similar to that (old version for SATA1) also from StarTech. Never had corruption or other types of problems but never used it full time.

Maybe the one you had working for a couple of weeks overheated and burned something?

StarTech boards usually work OK but read all the documentation and the fine printing on their site before you buy to make sure it is compatible.

Some years ago I bought a rather expensive softraid controller from them that worked fine until I changed the motherboard (same year/chipset but different manufacturer). It stop working and had a major caveat. It only works if the MMU setting on the BIOS is disabled (which the "new" motherboard does not support disabling) WTF | :WTF:

I had a couple of them deployed and they ended up corrupting the hard drives so I shelved the trial at that point. And you're exactly right about StarTech stuff. Laugh | :laugh:

Hmmm...you've just reminded me I have a box full of old drives, some IDE, that I should probably hook up to a system, copy whatever might still exist on them (if worthwhile, and I don't have any other copy of), then run through DBAN.

At this point, it's not worth hanging on to hardware so old it's getting difficult to hook up to newer systems.

How many do you have? I might be interested. Laugh | :laugh:

I just dug up the box. These are the IDE drives I have:

40GB
80GB (x2)
120GB (x3)
160GB
200GB

As I mentioned, I'd run them through DBAN first. As far as I can remember, they were all working last time I tried to use them. Which was probably years ago.

I can't imagine cost of shipping would make them worth it. What would you do with them?

They would be imaged and run on an commercial printing press. I'm interested, but at the same time, I don't think I can finagle a way to pay you without raising issues from the accounting boys. I appreciate you checking though. Thumbs Up | :thumbsup:

Welcome to the Lounge