{"id":14277,"date":"2026-06-09T01:00:00","date_gmt":"2026-06-09T05:00:00","guid":{"rendered":"https:\/\/www.both.org\/?p=14277"},"modified":"2026-06-04T17:39:56","modified_gmt":"2026-06-04T21:39:56","slug":"learn-by-writing-test-programs","status":"publish","type":"post","link":"http:\/\/www.both.org\/?p=14277","title":{"rendered":"Learn by writing test programs"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n <\/span>\r\n<\/div><\/div>\n

After writing about how DOS filenames can have spaces<\/a> and a follow-up article about where those spaces can be<\/a>, I’ve received a few emails asking which characters are allowed in DOS filenames, and which are not. Wikipedia has an excellent discussion about the DOS directory table<\/a> which includes the legal characters for DOS filenames, but this is an opportunity to learn a bit about programming.<\/p>\n\n\n\n

A power multiplier<\/em> in open source is that if you have a compiler and know a bit about programming, you can learn all kinds of things about how computer work. And in this case, we can learn about what characters are allowed in DOS filenames by writing a test program.<\/p>\n\n\n\n

Test all characters<\/h2>\n\n\n\n

DOS filnames can actually contain so-called “extended ASCII” characters. Really, the ASCII standard only defines characters from 0 to 127, and any character beyond that is a special character. DOS uses code points from 128 to 255 in a code page<\/em>, such as code page 437 (the typical “extended ASCII” characters that includes line-drawing characters, Greek characters, and other items). However, US keyboards cannot easily type those extra characters, so let’s make a test program that creates filenames using characters up to but not including<\/em> 127. Code point 127 is actually the “delete” character, and isn’t actually allowed in DOS filenames anyway.<\/p>\n\n\n\n

Let’s write a short test program that iterates through the printable characters in a for<\/code> loop:<\/p>\n\n\n\n

#include <stdio.h>\n\nint main()\n{\n    char x;\n\n    for (x=' '+1; x<127; x++) {\n        testfile(x);\n    }\n\n    return 0;\n}<\/code><\/pre>\n\n\n\n
This starts the loop at the character after<\/em> the space, which is the !<\/code> character. I wrote it as space + 1<\/strong> because we already know that DOS filenames cannot have a trailing space<\/a> so there’s no point in testing a space in a filename; we already know that answer. The loop continues as long as<\/em> the character is up to but not including<\/em> 127.<\/p>\n\n\n\n
For each character in the loop, the program calls the testfile<\/code> function. That’s the function where we’ll do the actual test.<\/p>\n\n\n\n
Save a test file<\/h2>\n\n\n\n
The testfile<\/code> function uses the character to create a filename, then opens a file, writes some data to it, and closes it. To make these test files easy to delete later, I’ll name them all with a .TST<\/code> file extension.<\/p>\n\n\n\n
int testfile(char a)\n{\n    char filename[] = \"_.TST\";<\/code><\/pre>\n\n\n\n
I’ve defined a string called filename<\/code> with the initial value _.TST<\/code>. The first character in the string is actually a placeholder; I’ll replace it with the a<\/strong> character before I try to open a new file with that name:<\/p>\n\n\n\n
    filename[0] = a;\n    p = fopen(filename, \"w\");<\/code><\/pre>\n\n\n\n
With that understanding of how the testfile<\/code> function works, let’s write the full function:<\/p>\n\n\n\n
int testfile(char a)\n{\n    char filename[] = \"_.TST\";\n    FILE *p;\n\n    fputc(a, stdout);\n    fputs(\" - \", stdout);\n\n    filename[0] = a;\n    p = fopen(filename, \"w\");\n\n    if (p==NULL) {\n        puts(\"fail\");\n        return 0; \/* fail *\/\n    }\n\n    fputc(a, p);\n    fclose(p);\n\n    puts(\"Ok\");\n    return 1;\n}<\/code><\/pre>\n\n\n\n
If the function cannot open a new file with that filename, it prints a “fail” message, then immediately exits. Otherwise, it writes one character to the file, then closes it. If successful, the function also prints an “Ok” message.<\/p>\n\n\n\n
Putting it all together<\/h2>\n\n\n\n
This program is not very long, at about 40 lines to test each character in a DOS filename. And that’s an important goal when you’re trying to learn something: write a simple program to test one thing<\/em>. In this case, the program only tests characters in DOS filenames. Here’s the full program:<\/p>\n\n\n\n
#include <stdio.h>\n\nint testfile(char a)\n{\n    char filename[] = \"_.TST\";\n    FILE *p;\n\n    fputc(a, stdout);\n    fputs(\" - \", stdout);\n\n    filename[0] = a;\n    p = fopen(filename, \"w\");\n\n    if (p==NULL) {\n        puts(\"fail\");\n        return 0; \/* fail *\/\n    }\n\n    fputc(a, p);\n    fclose(p);\n\n    puts(\"Ok\");\n    return 1;\n}\n\nint main()\n{\n    char x;\n\n    for (x=' '+1; x<127; x++) {\n        testfile(x);\n    }\n\n    return 0;\n}<\/code><\/pre>\n\n\n\n
I’ve saved this as names.c<\/strong> and compiled it using a C compiler. You should be able to use any ANSI-compatible C compiler; for example, we include Open Watcom in the FreeDOS distribution:<\/p>\n\n\n\n
D:\\SRC\\NAMES> wcl -q names.c<\/code><\/pre>\n\n\n\n
Testing the program<\/h2>\n\n\n\n
After we compile the program, we can use it to test which characters are allowed in a DOS filename. To make it easy to clean up after myself, I ran the program in a new TST<\/strong> directory; that way, I can just delete the directory later:<\/p>\n\n\n\n
D:\\SRC\\NAMES>mkdir tst\nD:\\SRC\\NAMES>cd tst\nD:\\SRC\\NAMES\\TST>..\\names > ..\\names.txt<\/code><\/pre>\n\n\n\n
The program will loop through all characters from !<\/code> (33) to ~<\/code> (126). For each character, the program tries to write a new file with a name like _.TST<\/code>. I’ve saved the output to a file called names.txt<\/code>, but you can just list the directory to see what files are there; these are the valid characters in a DOS filename:<\/p>\n\n\n\n
D:\\SRC\\NAMES\\TST>dir \/w \/l \/b\n[.]            [..]           !.tst          #.tst          $.tst\n%.tst          &.tst          '.tst          (.tst          ).tst\n-.tst          0.tst          1.tst          2.tst          3.tst\n4.tst          5.tst          6.tst          7.tst          8.tst\n9.tst          @.tst          a.tst          b.tst          c.tst\nd.tst          e.tst          f.tst          g.tst          h.tst\ni.tst          j.tst          k.tst          l.tst          m.tst\nn.tst          o.tst          p.tst          q.tst          r.tst\ns.tst          t.tst          u.tst          v.tst          w.tst\nx.tst          y.tst          z.tst          ^.tst          _.tst\n`.tst          {.tst          }.tst          ~.tst<\/code><\/pre>\n\n\n\n
Note that DOS filenames are case insensitive, so A.TST<\/code> is the same as A.TST<\/code>.<\/p>\n\n\n\n
With this directory list, we can see that the valid “plain ASCII” characters for DOS filenames are the letters A to Z, the numbers 0 to 9, and these special characters: ! # $ % & ‘ ( ) – @ ^ _ ` { } ~ (and space, with the caveat that you cannot have trailing spaces).<\/p>\n\n\n\n
Looking at the “fail” entries in the names.txt<\/code> file, we can see the list of characters that are not<\/em> allowed in regular DOS filenames:<\/p>\n\n\n\n
D:\\SRC\\NAMES\\TST>find \"fail\" ..\\names.txt\n---------------- NAMES.TXT\n\" - fail\n* - fail\n+ - fail\n, - fail\n. - fail\n\/ - fail\n: - fail\n; - fail\n< - fail\n= - fail\n> - fail\n? - fail\n[ - fail\n\\ - fail\n] - fail\n| - fail<\/code><\/pre>\n\n\n\n
Learn by writing test programs<\/h2>\n\n\n\n
With a little knowledge of programming, you can learn all kinds of things about how computers work. With this simple test program, we were able to demonstrate what characters are (and are not) allowed in DOS filenames.<\/p>\n","protected":false},"excerpt":{"rendered":"
With a little knowledge of programming, you can learn all kinds of things about how computers work<\/p>\n","protected":false},"author":33,"featured_media":2949,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","footnotes":""},"categories":[340,158,150],"tags":[267,108,152],"class_list":["post-14277","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-freedos","category-open-source","category-programming","tag-freedos","tag-open-source","tag-programming"],"modified_by":"David Both","_links":{"self":[{"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14277","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/users\/33"}],"replies":[{"embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=14277"}],"version-history":[{"count":1,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14277\/revisions"}],"predecessor-version":[{"id":14278,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/posts\/14277\/revisions\/14278"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=\/wp\/v2\/media\/2949"}],"wp:attachment":[{"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=14277"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=14277"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.both.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=14277"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}